Beispiel #1
0
    def __init__(self, index, isPlaylistEmpty, hasUndo, hasRedo, parent=None):
        QMenu.__init__(self, parent)

        self.trackIndex = index
        self.w = PlaylistMenuWidget()

        if index.row() != -1:
            self.addAction(self.w.play)
            self.w.play.triggered.connect(self._onPlay)
            self.addAction(self.w.remove)
            self.w.remove.triggered.connect(self._onRemove)

        if not isPlaylistEmpty:
            self.addAction(self.w.clear)
            self.w.clear.triggered.connect(self._onClear)

            self.addAction(self.w.save)
            self.w.save.triggered.connect(self._onSave)

        if hasUndo:
            self.addAction(self.w.undo)
            self.w.undo.triggered.connect(self._onUndo)

        if hasRedo:
            self.addAction(self.w.redo)
            self.w.redo.triggered.connect(self._onRedo)

        self.addAction(self.w.reconnect)
        self.w.reconnect.triggered.connect(self._onReconnect)
Beispiel #2
0
 def getCustomContextMenu(self, point: QPoint):
     """
     Args:
         point: the point to place the context menu
     """
     sgv = self.slice_graphics_view
     do_show = False
     menu = None
     if len(self.selection_set) > 0:
         menu = QMenu(sgv)
         copy_act = QAction("copy selection", sgv)
         copy_act.setStatusTip("copy selection")
         copy_act.triggered.connect(self.copySelection)
         menu.addAction(copy_act)
         delete_act = QAction("delete selection", sgv)
         delete_act.setStatusTip("delete selection")
         delete_act.triggered.connect(self.deleteSelection)
         menu.addAction(delete_act)
         do_show = True
     if self.clip_board is not None:
         if menu is None:
             menu = QMenu(sgv)
         copy_act = QAction("paste", sgv)
         copy_act.setStatusTip("paste from clip board")
         copy_act.triggered.connect(self.pasteClipboard)
         menu.addAction(copy_act)
         do_show = True
     if do_show:
         # def menuClickSet(event):
         #     self.menu_pos = event.globalPos()
         #     return QMenu.mousePressEvent(menu, event)
         # menu.mousePressEvent = menuClickSet
         menu.exec_(sgv.mapToGlobal(point))
Beispiel #3
0
class PredicateNodeInfo(NodeInfo):
    """
    This class implements the information box for predicate nodes.
    """
    def __init__(self, mainwindow, parent=None):
        """
        Initialize the predicate node information box.
        """
        super().__init__(mainwindow, parent)

        self.brushKey = Key('Color', self)
        self.brushMenu = QMenu(self)
        for action in self.mainwindow.actionsChangeNodeBrush:
            self.brushMenu.addAction(action)
        self.brushButton = Button()
        self.brushButton.setMenu(self.brushMenu)
        self.brushButton.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)

        self.nodePropLayout.addRow(self.brushKey, self.brushButton)

    def updateData(self, node):
        """
        Fetch new information and fill the widget with data.
        :type node: AbstractNode
        """
        super().updateData(node)
        for action in self.mainwindow.actionsChangeNodeBrush:
            color = action.data()
            brush = QBrush(QColor(color.value))
            if node.brush == brush:
                self.brushButton.setIcon(ColoredIcon(12, 12, color.value, '#000000'))
                self.brushButton.setText(color.value)
                break
Beispiel #4
0
 def _get_menu(self):
     # main menu
     menu = QMenu()
     main_menu_action_group = QActionGroup(menu)
     main_menu_action_group.setObjectName("main")
     # character menu
     map_action = QAction(menu)
     map_action.setText("Toggle Map")
     main_menu_action_group.addAction(map_action)
     separator = QAction(menu)
     separator.setSeparator(True)
     main_menu_action_group.addAction(separator)
     characters_action = QAction(menu)
     characters_action.setText("Switch Characters")
     main_menu_action_group.addAction(characters_action)
     separator = QAction(menu)
     separator.setSeparator(True)
     main_menu_action_group.addAction(separator)
     settings_action = QAction(menu)
     settings_action.setText("Settings")
     main_menu_action_group.addAction(settings_action)
     quit_action = QAction(menu)
     quit_action.setText("Quit")
     main_menu_action_group.addAction(quit_action)
     menu.addActions(main_menu_action_group.actions())
     menu.triggered[QAction].connect(self._menu_actions)
     return menu
Beispiel #5
0
class ValueDomainNodeInfo(PredicateNodeInfo):
    """
    This class implements the information box for the Value Domain node.
    """
    def __init__(self, mainwindow, parent=None):
        """
        Initialize the Value Domain node information box.
        """
        super().__init__(mainwindow, parent)

        self.datatypeKey = Key('Datatype', self)
        self.datatypeMenu = QMenu(self)
        for action in self.mainwindow.actionsChangeValueDomainDatatype:
            self.datatypeMenu.addAction(action)
        self.datatypeButton = Button()
        self.datatypeButton.setMenu(self.datatypeMenu)
        self.datatypeButton.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)

        self.nodePropLayout.addRow(self.datatypeKey, self.datatypeButton)

    def updateData(self, node):
        """
        Fetch new information and fill the widget with data.
        :type node: AbstractNode
        """
        super().updateData(node)
        datatype = node.datatype
        for action in self.mainwindow.actionsChangeValueDomainDatatype:
            action.setChecked(action.data() is datatype)
        self.datatypeButton.setText(datatype.value)
Beispiel #6
0
    def __init__(self, titre='', liste=None, fonction=None, aide=''):
        QMenu.__init__(self, titre)
#        self.parent = parent
        self.fonction = None
#        self.titre = titre
#        self.setTitle(titre)
        self.update(liste, fonction, aide)
Beispiel #7
0
	def init_stat_bar(self):
		self.status_bar = self.statusBar()
		self.status_bar.setMaximumHeight(20)
		self.status_bar.setSizeGripEnabled(False)
		self.stat_info = QLabel()
		self.stat_info.setIndent(5)
		self.sort_main = QAction("Asc", self)
		sort_menu = QMenu()
		self.sort_main.setMenu(sort_menu)
		s_by_title = QAction("Title", sort_menu)
		s_by_artist = QAction("Artist", sort_menu)
		sort_menu.addAction(s_by_title)
		sort_menu.addAction(s_by_artist)
		self.status_bar.addPermanentWidget(self.stat_info)
		#self.status_bar.addAction(self.sort_main)
		self.temp_msg = QLabel()
		self.temp_timer = QTimer()

		self.manga_list_view.gallery_model.ROWCOUNT_CHANGE.connect(self.stat_row_info)
		self.manga_list_view.gallery_model.db_emitter.COUNT_CHANGE.connect(self.stat_row_info)
		self.manga_list_view.gallery_model.STATUSBAR_MSG.connect(self.stat_temp_msg)
		self.manga_list_view.STATUS_BAR_MSG.connect(self.stat_temp_msg)
		self.manga_table_view.STATUS_BAR_MSG.connect(self.stat_temp_msg)
		self.stat_row_info()
		app_constants.STAT_MSG_METHOD = self.stat_temp_msg
Beispiel #8
0
class Systray(QObject):
    trayIconMenu = None

    def __init__(self, parent):
        super().__init__(parent)

        self.trayIconMenu = QMenu(None)

        icon = QIcon(":/image/thunder.ico")

        self.trayIcon = CompatSystemTrayIcon(self)
        self.trayIcon.setIcon(icon)
        self.trayIcon.setContextMenu(self.trayIconMenu)
        self.trayIcon.setVisible(True)

        self.trayIcon.activated.connect(self.slotSystrayActivated)
        self.trayIconMenu.addAction(app.mainWin.action_exit)

    @pyqtSlot(QSystemTrayIcon.ActivationReason)
    def slotSystrayActivated(self, reason):
        if reason == QSystemTrayIcon.Context:  # right
            pass
        elif reason == QSystemTrayIcon.MiddleClick:  # middle
            pass
        elif reason == QSystemTrayIcon.DoubleClick:  # double click
            pass
        elif reason == QSystemTrayIcon.Trigger:  # left
            if app.mainWin.isHidden() or app.mainWin.isMinimized():
                app.mainWin.restore()
            else:
                app.mainWin.minimize()
Beispiel #9
0
    def __init__(self):
        QMainWindow.__init__(self)
        self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
        self.setWindowTitle("程序主窗口")

        self.file_menu = QMenu('&File', self)
        self.file_menu.addAction('&Quit', self.fileQuit,
                                 QtCore.Qt.CTRL + QtCore.Qt.Key_Q)
        self.menuBar().addMenu(self.file_menu)

        self.help_menu = QMenu('&Help', self)
        self.menuBar().addSeparator()
        self.menuBar().addMenu(self.help_menu)

        self.help_menu.addAction('&About', self.about)

        self.main_widget = QWidget(self)

        l = QVBoxLayout(self.main_widget)
        sc = MyStaticMplCanvas(self.main_widget, width=5, height=4, dpi=100)
        dc = MyDynamicMplCanvas(self.main_widget, width=5, height=4, dpi=100)
        l.addWidget(sc)
        l.addWidget(dc)

        self.main_widget.setFocus()
        self.setCentralWidget(self.main_widget)
        # 状态条显示2秒
        self.statusBar().showMessage("matplotlib 万岁!", 2000)
Beispiel #10
0
 def __init__(self, parent, viewmanager):
     """
     Constructor
     
     @param parent the parent (QWidget)
     @param viewmanager reference to the viewmanager object
     """
     super(TemplateViewer, self).__init__(parent)
     
     self.viewmanager = viewmanager
     self.groups = {}
     
     self.setHeaderLabels(["Template"])
     self.header().hide()
     self.header().setSortIndicator(0, Qt.AscendingOrder)
     self.setRootIsDecorated(True)
     self.setAlternatingRowColors(True)
     
     self.__menu = QMenu(self)
     self.applyAct = self.__menu.addAction(
         self.tr("Apply"), self.__templateItemActivated)
     self.__menu.addSeparator()
     self.__menu.addAction(self.tr("Add entry..."), self.__addEntry)
     self.__menu.addAction(self.tr("Add group..."), self.__addGroup)
     self.__menu.addAction(self.tr("Edit..."), self.__edit)
     self.__menu.addAction(self.tr("Remove"), self.__remove)
     self.__menu.addSeparator()
     self.saveAct = self.__menu.addAction(self.tr("Save"), self.save)
     self.__menu.addAction(self.tr("Import..."), self.__import)
     self.__menu.addAction(self.tr("Export..."), self.__export)
     self.__menu.addAction(self.tr("Reload"), self.__reload)
     self.__menu.addSeparator()
     self.__menu.addAction(
         self.tr("Help about Templates..."), self.__showHelp)
     self.__menu.addSeparator()
     self.__menu.addAction(self.tr("Configure..."), self.__configure)
     
     self.__backMenu = QMenu(self)
     self.__backMenu.addAction(self.tr("Add group..."), self.__addGroup)
     self.__backMenu.addSeparator()
     self.bmSaveAct = self.__backMenu.addAction(self.tr("Save"), self.save)
     self.__backMenu.addAction(self.tr("Import..."), self.__import)
     self.bmExportAct = self.__backMenu.addAction(
         self.tr("Export..."), self.__export)
     self.__backMenu.addAction(self.tr("Reload"), self.__reload)
     self.__backMenu.addSeparator()
     self.__backMenu.addAction(
         self.tr("Help about Templates..."), self.__showHelp)
     self.__backMenu.addSeparator()
     self.__backMenu.addAction(
         self.tr("Configure..."), self.__configure)
     
     self.__activating = False
     self.__dirty = False
     
     self.setContextMenuPolicy(Qt.CustomContextMenu)
     self.customContextMenuRequested.connect(self.__showContextMenu)
     self.itemActivated.connect(self.__templateItemActivated)
     
     self.setWindowIcon(UI.PixmapCache.getIcon("eric.png"))
    def __init__(self, parent=None):
        super(ZMQPublisherInfoWidget, self).__init__(parent)

        ui_class, widget_class = uic.loadUiType(os.path.split(__file__)[0] + "/zmqPubSubInfoWidget.ui")
        self.ui = ui_class()
        self.ui.setupUi(self)

        self.status = {
            "pub": {
                "address": None,
                "running": False
            },
            "sub": {
                "address": None,
                "running": False
            }
        }

        self.ui.toggleSubStatus.clicked.connect(partial(self.ui.toggleSubStatus.setEnabled, False))
        self.ui.togglePubStatus.clicked.connect(partial(self.ui.togglePubStatus.setEnabled, False))
        self.ui.toggleSubStatus.clicked.connect(self.subStatusToggled.emit)
        self.ui.togglePubStatus.clicked.connect(self.pubStatusToggled.emit)

        menu = QMenu("options")
        self.change_pub_addr_action = menu.addAction("Change Address", self.changePubAddress.emit)
        self.ui.togglePubStatus.setMenu(menu)

        menu = QMenu("options")
        self.change_sub_addr_action = menu.addAction("Change Address", self.changeSubAddress.emit)
        self.ui.toggleSubStatus.setMenu(menu)

        self.status_style = "background-color: %s; border: 3px inset gray; padding: 5px"
Beispiel #12
0
    def __init__(self):
        super(MainWindow, self).__init__()

        fileMenu = QMenu("&File", self)
        openAction = fileMenu.addAction("&Open...")
        openAction.setShortcut("Ctrl+O")
        saveAction = fileMenu.addAction("&Save As...")
        saveAction.setShortcut("Ctrl+S")
        quitAction = fileMenu.addAction("E&xit")
        quitAction.setShortcut("Ctrl+Q")

        self.setupModel()
        self.setupViews()

        openAction.triggered.connect(self.openFile)
        saveAction.triggered.connect(self.saveFile)
        quitAction.triggered.connect(QApplication.instance().quit)

        self.menuBar().addMenu(fileMenu)
        self.statusBar()

        self.openFile(':/Charts/qtdata.cht')

        self.setWindowTitle("Chart")
        self.resize(870, 550)
 def __cookiesListContextMenuRequested(self, pos):
     """
     Private slot handling the cookies list context menu.
     
     @param pos position to show the menu at
     @type QPoint
     """
     itm = self.cookiesList.itemAt(pos)
     if itm is None:
         return
     
     menu = QMenu()
     addBlacklistAct = menu.addAction(self.tr("Add to blacklist"))
     addWhitelistAct = menu.addAction(self.tr("Add to whitelist"))
     
     self.cookiesList.setCurrentItem(itm)
     
     activatedAction = menu.exec_(
         self.cookiesList.viewport().mapToGlobal(pos))
     if itm.childCount() == 0:
         origin = itm.data(0, Qt.UserRole).origin
     else:
         origin = itm.text(0)
     
     if activatedAction == addBlacklistAct:
         self.__addBlacklist(origin)
     elif activatedAction == addWhitelistAct:
         self.__addWhitelist(origin)
Beispiel #14
0
    def __init__(self, project, settings):
        QWidget.__init__(self)
        self.ui = Ui_ProjectWidget()
        self.ui.setupUi(self)
        self.project = project
        self.project.filesChanged.connect(self.refresh)
        self.toolbar = QToolBar()
        import_image = lambda: ImportImage.pick(lambda f: self.import_image.emit(f[0]), settings)
        self.toolbar.addAction(ImportImage.icon(), ImportImage.ACTION_TEXT, import_image)
        self.ui.import_image.clicked.connect(import_image)
        self.raw_spectra_model = QStandardItemModel()
        self.calibrated_spectra_model = QStandardItemModel()
        self.finished_spectra_model = QStandardItemModel()

        def button_action(button, signal, widget, model):
            button.clicked.connect(lambda: signal.emit(model.item(widget.selectionModel().selectedRows()[0].row()).data() ) )
            widget.selectionModel().selectionChanged.connect(lambda sel, unsel: button.setEnabled(len(sel.indexes())>0))
            
        for model, widget in [(self.raw_spectra_model, self.ui.raw_spectra), (self.calibrated_spectra_model, self.ui.calibrated_spectra), (self.finished_spectra_model, self.ui.finished_spectra)]:
            widget.setModel(model)
            widget.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
            
        button_action(self.ui.calibrate, self.calibrate, self.ui.raw_spectra, self.raw_spectra_model)
        button_action(self.ui.math, self.math, self.ui.calibrated_spectra, self.calibrated_spectra_model)
        button_action(self.ui.finish, self.finish, self.ui.calibrated_spectra, self.calibrated_spectra_model)
        button_action(self.ui.open_finished, self.finish, self.ui.finished_spectra, self.finished_spectra_model)
        open_finished_menu = QMenu()
        self.ui.open_finished_dirs.setMenu(open_finished_menu)
        open_finished_menu.addAction(QIcon(':/image_20'), 'Exported Images folder', lambda: QDesktopServices.openUrl(QUrl.fromLocalFile(project.directory_path(Project.EXPORTED_IMAGES))))
        open_finished_menu.addAction(QIcon(':/done_20'), 'Finished Spectra folder', lambda: QDesktopServices.openUrl(QUrl.fromLocalFile(project.directory_path(Project.FINISHED_PROFILES))))
        

            
        self.refresh()
    def slot_transportViewMenu(self):
        menu = QMenu(self)
        actHMS    = menu.addAction("Hours:Minutes:Seconds")
        actBBT    = menu.addAction("Beat:Bar:Tick")
        actFrames = menu.addAction("Frames")

        actHMS.setCheckable(True)
        actBBT.setCheckable(True)
        actFrames.setCheckable(True)

        if self.fCurTransportView == TRANSPORT_VIEW_HMS:
            actHMS.setChecked(True)
        elif self.fCurTransportView == TRANSPORT_VIEW_BBT:
            actBBT.setChecked(True)
        elif self.fCurTransportView == TRANSPORT_VIEW_FRAMES:
            actFrames.setChecked(True)

        actSelected = menu.exec_(QCursor().pos())

        if actSelected == actHMS:
            self.setTransportView(TRANSPORT_VIEW_HMS)
        elif actSelected == actBBT:
            self.setTransportView(TRANSPORT_VIEW_BBT)
        elif actSelected == actFrames:
            self.setTransportView(TRANSPORT_VIEW_FRAMES)
Beispiel #16
0
class CurrentPlaylistTable(MusicTable):
    remove_signal = pyqtSignal([int])   # song id

    def __init__(self, app):
        super().__init__(app)
        self._app = app

        self._row = 0

        self.menu = QMenu()
        self.remove = QAction('从当前列表中移除', self)
        self.menu.addAction(self.remove)

        self.remove.triggered.connect(self.remove_song)

    def contextMenuEvent(self, event):
        point = event.pos()
        item = self.itemAt(point)
        if item is not None:
            row = self.row(item)
            self._row = row
            self.menu.exec(event.globalPos())

    def remove_song(self):
        song = self.songs[self._row]
        self.songs.pop(self._row)
        self.removeRow(self._row)
        self.remove_signal.emit(song.mid)
Beispiel #17
0
class ApplicationWindow(QMainWindow):
    def __init__(self):
        QMainWindow.__init__(self)
        self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
        self.setWindowTitle("application main window")

        self.file_menu = QMenu('&File', self)
        self.file_menu.addAction('&Quit', self.fileQuit,
        QtCore.Qt.CTRL + QtCore.Qt.Key_Q)
        self.menuBar().addMenu(self.file_menu)

        self.help_menu = QMenu('&Help', self)
        self.menuBar().addSeparator()
        self.menuBar().addMenu(self.help_menu)

        self.main_widget = QWidget(self)

        l = QVBoxLayout(self.main_widget)
        sc = MyStaticMplCanvas(self.main_widget, width=5, height=4, dpi=100)
        dc = MyDynamicMplCanvas(self.main_widget, width=5, height=4, dpi=100)
        l.addWidget(sc)
        l.addWidget(dc)

        self.main_widget.setFocus()
        self.setCentralWidget(self.main_widget)

        self.statusBar().showMessage("All hail matplotlib!", 2000)

    def fileQuit(self):
        self.close()

    def closeEvent(self, ce):
        self.fileQuit()
Beispiel #18
0
    def right_click(self, type, champ):
        "Retourne une fonction qui sera executée lors d'un clic droit sur le champ 'champ'."
        champ.setFocus()
        plusieurs = isinstance(type, list)
        if plusieurs:
            type = type[0]
        liste_objets = self.onglet_actuel.feuille_actuelle.objets.lister(False, type = type)
        liste_objets.sort(key = attrgetter('nom')) # ordre alphabétique
        if not liste_objets:
            return
        menu = QMenu()

        for obj in liste_objets:
            action = menu.addAction(obj.nom_complet)
            action.nom = obj.nom

        action = menu.exec_(QCursor.pos())
        if action:
            if plusieurs:
                # le champ doit contenir non pas un objet, mais une liste d'objets
                val = champ.text().strip()
                if val:
                    if not val.endswith(","):
                        val += ","
                    val += " "
                champ.setText(val + action.nom)
            else:
                # le champ contient un seul objet
                champ.setText(action.nom)
Beispiel #19
0
    def buildWidget(self):
        layout = QHBoxLayout(self)
        layout.setContentsMargins(0,0,0,0)
        SettingMenu = QMenu()
        exitButton = QAction(QIcon('exit24.png'), 'Set As High', self)
        exitButton.triggered.connect(self.setHigh)
        SettingMenu.addAction(exitButton)
        setlowButton = QAction(QIcon('exit24.png'), 'Set As Low', self)
        setlowButton.triggered.connect(self.setLow)
        SettingMenu.addAction(setlowButton)

        self.tb_down = QToolButton()
        self.tb_down.pressed.connect(self.on_click_down)
        self.tb_down.released.connect(self.on_released)
        self.tb_down.setArrowType(Qt.LeftArrow)

        self.tb_up = QToolButton()
        self.tb_up.pressed.connect(self.on_click_up)
        self.tb_up.released.connect(self.on_released)
        self.tb_up.setArrowType(Qt.RightArrow)

        if self.showToggleButton:
            tb_set = QToolButton()
            tb_set.clicked.connect(self.on_click_set_value)
            tb_set.setText('<>')
            if self.showSettingMenu:
                tb_set.setMenu(SettingMenu)
                tb_set.setPopupMode(QToolButton.DelayedPopup)

        layout.addWidget(self.tb_down)
        layout.addWidget(self.bar)
        layout.addWidget(self.tb_up)
        if self.showToggleButton:
            layout.addWidget(tb_set)
        layout.setSpacing(0)
Beispiel #20
0
    def __init__(self, labels=[]):
        super().__init__()
        menu = QMenu(self)
        def buttonFuncMaker(lab):
            def buttonFunc():
                self.setText(lab)
                self.stateChanged.emit()
            return buttonFunc

        for t in labels:
            action = menu.addAction(t)
            action.triggered.connect(buttonFuncMaker(t))
        self.setSizePolicy(QSizePolicy())
        self.setMenu(menu)
        self.setFlat(True)
        self.setStyleSheet('''
            QPushButton {
                border-width: 1px;
                border-style: solid;
                border-radius: 7px;
                border-color: gray;
                padding: 1px 3px 1px 3px;
            }
            QPushButton:pressed {
                background-color: gray;
            }
            QPushButton::menu-indicator{
                image: url(none.jpg);
                width: 0px;
            }
        ''')
    def _handle_context_menu_requested(self, qpoint):
        index = self.treeView.indexAt(qpoint)
        item = index.internalPointer()

        def add_action(menu, text, handler, icon=None):
            a = None
            if icon is None:
                a = QAction(text, self)
            else:
                a = QAction(icon, text, self)
            a.triggered.connect(handler)
            menu.addAction(a)

        menu = QMenu(self)

        action = None
        if self._is_item_colored(item):
            add_action(menu, "De-color item", lambda: self._handle_clear_color_item(item))
        else:
            add_action(menu, "Color item", lambda: self._handle_color_item(item))
            color_menu = menu.addMenu("Color item...")

            # need to escape the closure capture on the color loop variable below
            # hint from: http://stackoverflow.com/a/6035865/87207
            def make_color_item_handler(item, color):
                return lambda: self._handle_color_item(item, color=color)

            for color in QT_COLORS:
                add_action(color_menu, "{:s}".format(color.name),
                           make_color_item_handler(item, color.qcolor), make_color_icon(color.qcolor))

        add_action(menu, "Set name...", lambda: self._handle_set_name(item))

        menu.exec_(self.treeView.mapToGlobal(qpoint))
Beispiel #22
0
 def contextMenuEvent(self, event):
     menu = QMenu(self)
     local_filename = self.currentItem().text()
     # Get the file extension
     ext = os.path.splitext(local_filename)[1].lower()
     open_internal_action = None
     # Mu micro:bit mode only handles .py & .hex
     if ext == '.py' or ext == '.hex':
         open_internal_action = menu.addAction(_("Open in Mu"))
     # Open outside Mu (things get meta if Mu is the default application)
     open_action = menu.addAction(_("Open"))
     action = menu.exec_(self.mapToGlobal(event.pos()))
     if action == open_action:
         # Get the file's path
         path = os.path.join(self.home, local_filename)
         logger.info("Opening {}".format(path))
         msg = _("Opening '{}'").format(local_filename)
         logger.info(msg)
         self.set_message.emit(msg)
         # Let Qt work out how to open it
         QDesktopServices.openUrl(QUrl.fromLocalFile(path))
     elif action == open_internal_action:
         logger.info("Open {} internally".format(local_filename))
         # Get the file's path
         path = os.path.join(self.home, local_filename)
         # Send the signal bubbling up the tree
         self.open_file.emit(path)
    def contextMenuEvent(self, event):
        # Set context menu mode
        app = get_app()
        app.context_menu_object = "transitions"

        menu = QMenu(self)
        menu.addAction(self.win.actionThumbnailView)
        menu.exec_(QCursor.pos())
    def contextMenuEvent(self, event):

        menu = QMenu(self)
        attachAction = menu.addAction(_("Add sheet"))
        attachAction.triggered.connect(self.add_sheet)
        menu.exec_(self.mapToGlobal(event.pos()))

        return QTreeView.contextMenuEvent(self, event)
Beispiel #25
0
 def create_menu(self, position):
     item = self.currentItem()
     if not item:
         return
     menu = QMenu()
     server = item.data(self.Columns.HOST, self.SERVER_STR_ROLE)
     menu.addAction(_("Use as server"), lambda: self.set_server(server))
     menu.exec_(self.viewport().mapToGlobal(position))
Beispiel #26
0
 def contextMenuEvent(self, e):
     """ Event handler.
     """
     menu = QMenu(self)
     menu.addActions([self.load, self.remove, self.clearList])
     # show the menu only if the mouse is pointing a list item
     if self.itemAt(e.pos()):
         menu.popup(e.globalPos())
Beispiel #27
0
 def __init__(self, parent=None):
     super().__init__(parent)
     trayIconMenu = QMenu(parent)
     self.restoreAction = QAction("Restore", trayIconMenu)
     self.quitAction = QAction("Quit", trayIconMenu)
     trayIconMenu.addAction(self.restoreAction)
     trayIconMenu.addAction(self.quitAction)
     self.setContextMenu(trayIconMenu)
Beispiel #28
0
 def mouseReleaseEvent(self, event):
     if event.button() == Qt.LeftButton and self.rect().contains(event.pos()):
         self.actions.remove_icon.setEnabled(self.icon is not self.contact_icon)
         menu = QMenu(self)
         menu.addAction(self.actions.select_icon)
         menu.addAction(self.actions.remove_icon)
         menu.exec_(self.mapToGlobal(self.rect().translated(0, 2).bottomLeft()))
     super(IconSelector, self).mouseReleaseEvent(event)
Beispiel #29
0
 def createUI(self):
     self.setWindowTitle('Equipment Manager 0.3')
     #Menu Bar
     fileMenuBar = QMenuBar(self)
     menuFile = QMenu(fileMenuBar)
     actionChangePath = QAction(tr("Change Path"), self)
     fileMenuBar.addMenu(menuFile)
     menuFile.addAction(actionChangePath)
    def contextMenuEvent(self, event):
        # Set context menu mode
        app = get_app()
        app.context_menu_object = "effects"

        menu = QMenu(self)
        menu.addAction(self.win.actionDetailsView)
        menu.exec_(QCursor.pos())
Beispiel #31
0
    def _openContextMenu(self, thePos):
        """Triggered by right click to open the context menu.
        """
        userCursor = self.textCursor()
        userSelection = userCursor.hasSelection()

        mnuContext = QMenu()

        # Cut, Copy and Paste
        # ===================

        if userSelection:
            mnuCopy = QAction(self.tr("Copy"), mnuContext)
            mnuCopy.triggered.connect(lambda: self.docAction(nwDocAction.COPY))
            mnuContext.addAction(mnuCopy)

            mnuContext.addSeparator()

        # Selections
        # ==========

        mnuSelAll = QAction(self.tr("Select All"), mnuContext)
        mnuSelAll.triggered.connect(lambda: self.docAction(nwDocAction.SEL_ALL))
        mnuContext.addAction(mnuSelAll)

        mnuSelWord = QAction(self.tr("Select Word"), mnuContext)
        mnuSelWord.triggered.connect(
            lambda: self._makePosSelection(QTextCursor.WordUnderCursor, thePos)
        )
        mnuContext.addAction(mnuSelWord)

        mnuSelPara = QAction(self.tr("Select Paragraph"), mnuContext)
        mnuSelPara.triggered.connect(
            lambda: self._makePosSelection(QTextCursor.BlockUnderCursor, thePos)
        )
        mnuContext.addAction(mnuSelPara)

        # Open the context menu
        mnuContext.exec_(self.viewport().mapToGlobal(thePos))

        return
Beispiel #32
0
    def setupUi(self, RocketSimWindow, screen):
        RocketSimWindow.setObjectName("RocketSimWindow")
        RocketSimWindow.resize(518, 636)
        self.centralwidget = QWidget(RocketSimWindow)
        self.centralwidget.setObjectName("centralwidget")
        self.gridLayout = QGridLayout(self.centralwidget)
        self.gridLayout.setObjectName("gridLayout")
        self.lineEdit = QLineEdit(self.centralwidget)
        self.lineEdit.setObjectName("lineEdit")
        self.lineEdit.setText(str(Globals.G))
        self.lineEdit.textChanged.connect(self.update_gravity)
        self.gridLayout.addWidget(self.lineEdit, 5, 1, 1, 1)
        self.pushButton = QPushButton(self.centralwidget)
        self.pushButton.setObjectName("pushButton")
        self.pushButton.clicked.connect(self.restart)
        self.gridLayout.addWidget(self.pushButton, 1, 2, 1, 1)
        self.graphicsView = ImageWidget(screen)
        self.graphicsView.setEnabled(True)
        self.graphicsView.setMouseTracking(False)
        self.graphicsView.setObjectName("graphicsView")
        self.gridLayout.addWidget(self.graphicsView, 0, 0, 1, 3)
        self.label_3 = QLabel(self.centralwidget)
        self.label_3.setObjectName("label_3")
        self.gridLayout.addWidget(self.label_3, 5, 0, 1, 1)
        self.horizontalSlider = QSlider(self.centralwidget)
        self.horizontalSlider.setOrientation(QtCore.Qt.Horizontal)
        self.horizontalSlider.setObjectName("horizontalSlider")
        self.horizontalSlider.setMinimum(0)
        self.horizontalSlider.setMaximum(180)
        self.horizontalSlider.valueChanged.connect(self.angle_change)
        self.gridLayout.addWidget(self.horizontalSlider, 3, 0, 1, 1)
        self.label = QLabel(self.centralwidget)
        self.label.setObjectName("label")
        self.gridLayout.addWidget(self.label, 1, 0, 1, 1)
        self.horizontalSlider_2 = QSlider(self.centralwidget)
        self.horizontalSlider_2.setOrientation(QtCore.Qt.Horizontal)
        self.horizontalSlider_2.setObjectName("horizontalSlider_2")
        self.horizontalSlider_2.setMinimum(0)
        self.horizontalSlider_2.setMaximum(10)
        self.horizontalSlider_2.valueChanged.connect(self.velocity_change)
        self.gridLayout.addWidget(self.horizontalSlider_2, 3, 1, 1, 1)
        self.label_2 = QLabel(self.centralwidget)
        self.label_2.setObjectName("label_2")
        self.gridLayout.addWidget(self.label_2, 1, 1, 1, 1)
        self.pushButton_2 = QPushButton(self.centralwidget)
        self.pushButton_2.setObjectName("pushButton_2")
        self.pushButton_2.clicked.connect(self.wait)
        self.gridLayout.addWidget(self.pushButton_2, 3, 2, 1, 1)
        RocketSimWindow.setCentralWidget(self.centralwidget)
        self.menubar = QMenuBar(RocketSimWindow)
        self.menubar.setGeometry(QtCore.QRect(0, 0, 518, 21))
        self.menubar.setObjectName("menubar")
        self.menuSymulacja = QMenu(self.menubar)
        self.menuSymulacja.setObjectName("menuSymulacja")
        self.menuEdytor_poziom_w = QMenu(self.menubar)
        self.menuEdytor_poziom_w.setObjectName("menuEdytor_poziom_w")
        RocketSimWindow.setMenuBar(self.menubar)
        self.actionSymulacja = QAction(RocketSimWindow)
        self.actionSymulacja.setObjectName("actionSymulacja")
        self.actionSymulacja.triggered.connect(ChangePlanetsWindow)
        self.actionEdytor_Poziom_w = QAction(RocketSimWindow)
        self.actionEdytor_Poziom_w.setEnabled(False)
        self.actionEdytor_Poziom_w.setObjectName("actionEdytor_Poziom_w")
        # self.actionWczytaj = QtWidgets.QAction(RocketSimWindow)
        # self.actionWczytaj.setObjectName("actionWczytaj")
        # self.actionZapisz = QtWidgets.QAction(RocketSimWindow)
        # self.actionZapisz.setObjectName("actionZapisz")
        self.actionWyj_cie = QAction(RocketSimWindow)
        self.actionWyj_cie.setObjectName("actionWyj_cie")
        self.actionWyj_cie.triggered.connect(self.quit)
        # self.menuSymulacja.addAction(self.actionZapisz)
        # self.menuSymulacja.addAction(self.actionWczytaj)
        self.menuSymulacja.addSeparator()
        self.menuSymulacja.addAction(self.actionWyj_cie)
        self.menuEdytor_poziom_w.addAction(self.actionSymulacja)
        self.menuEdytor_poziom_w.addAction(self.actionEdytor_Poziom_w)
        self.menubar.addAction(self.menuSymulacja.menuAction())
        self.menubar.addAction(self.menuEdytor_poziom_w.menuAction())
        oprogAct = QAction("O programie", self.centralwidget)
        oprogAct.triggered.connect(AboutWindow)
        self.menubar.addAction(oprogAct)

        self.retranslateUi(RocketSimWindow)
        QtCore.QMetaObject.connectSlotsByName(RocketSimWindow)
Beispiel #33
0
class Ui_RocketSimWindow(object):
    def velocity_change(self):
        Globals.init_v = self.horizontalSlider_2.value()
        self.label_2.setText("Prędkość początkowa: " + str(Globals.init_v))

    def angle_change(self):
        Globals.angle = self.horizontalSlider.value()
        self.label.setText("Kąt startu: " + str(Globals.angle))

    def wait(self):
        Globals.state = "wait"

    def restart(self):
        Globals.state = "restart"

    def quit(self):
        Globals.state = "quit"
        exit()

    def update_gravity(self):
        Globals.G = float(str(self.lineEdit.text()))

    def setupUi(self, RocketSimWindow, screen):
        RocketSimWindow.setObjectName("RocketSimWindow")
        RocketSimWindow.resize(518, 636)
        self.centralwidget = QWidget(RocketSimWindow)
        self.centralwidget.setObjectName("centralwidget")
        self.gridLayout = QGridLayout(self.centralwidget)
        self.gridLayout.setObjectName("gridLayout")
        self.lineEdit = QLineEdit(self.centralwidget)
        self.lineEdit.setObjectName("lineEdit")
        self.lineEdit.setText(str(Globals.G))
        self.lineEdit.textChanged.connect(self.update_gravity)
        self.gridLayout.addWidget(self.lineEdit, 5, 1, 1, 1)
        self.pushButton = QPushButton(self.centralwidget)
        self.pushButton.setObjectName("pushButton")
        self.pushButton.clicked.connect(self.restart)
        self.gridLayout.addWidget(self.pushButton, 1, 2, 1, 1)
        self.graphicsView = ImageWidget(screen)
        self.graphicsView.setEnabled(True)
        self.graphicsView.setMouseTracking(False)
        self.graphicsView.setObjectName("graphicsView")
        self.gridLayout.addWidget(self.graphicsView, 0, 0, 1, 3)
        self.label_3 = QLabel(self.centralwidget)
        self.label_3.setObjectName("label_3")
        self.gridLayout.addWidget(self.label_3, 5, 0, 1, 1)
        self.horizontalSlider = QSlider(self.centralwidget)
        self.horizontalSlider.setOrientation(QtCore.Qt.Horizontal)
        self.horizontalSlider.setObjectName("horizontalSlider")
        self.horizontalSlider.setMinimum(0)
        self.horizontalSlider.setMaximum(180)
        self.horizontalSlider.valueChanged.connect(self.angle_change)
        self.gridLayout.addWidget(self.horizontalSlider, 3, 0, 1, 1)
        self.label = QLabel(self.centralwidget)
        self.label.setObjectName("label")
        self.gridLayout.addWidget(self.label, 1, 0, 1, 1)
        self.horizontalSlider_2 = QSlider(self.centralwidget)
        self.horizontalSlider_2.setOrientation(QtCore.Qt.Horizontal)
        self.horizontalSlider_2.setObjectName("horizontalSlider_2")
        self.horizontalSlider_2.setMinimum(0)
        self.horizontalSlider_2.setMaximum(10)
        self.horizontalSlider_2.valueChanged.connect(self.velocity_change)
        self.gridLayout.addWidget(self.horizontalSlider_2, 3, 1, 1, 1)
        self.label_2 = QLabel(self.centralwidget)
        self.label_2.setObjectName("label_2")
        self.gridLayout.addWidget(self.label_2, 1, 1, 1, 1)
        self.pushButton_2 = QPushButton(self.centralwidget)
        self.pushButton_2.setObjectName("pushButton_2")
        self.pushButton_2.clicked.connect(self.wait)
        self.gridLayout.addWidget(self.pushButton_2, 3, 2, 1, 1)
        RocketSimWindow.setCentralWidget(self.centralwidget)
        self.menubar = QMenuBar(RocketSimWindow)
        self.menubar.setGeometry(QtCore.QRect(0, 0, 518, 21))
        self.menubar.setObjectName("menubar")
        self.menuSymulacja = QMenu(self.menubar)
        self.menuSymulacja.setObjectName("menuSymulacja")
        self.menuEdytor_poziom_w = QMenu(self.menubar)
        self.menuEdytor_poziom_w.setObjectName("menuEdytor_poziom_w")
        RocketSimWindow.setMenuBar(self.menubar)
        self.actionSymulacja = QAction(RocketSimWindow)
        self.actionSymulacja.setObjectName("actionSymulacja")
        self.actionSymulacja.triggered.connect(ChangePlanetsWindow)
        self.actionEdytor_Poziom_w = QAction(RocketSimWindow)
        self.actionEdytor_Poziom_w.setEnabled(False)
        self.actionEdytor_Poziom_w.setObjectName("actionEdytor_Poziom_w")
        # self.actionWczytaj = QtWidgets.QAction(RocketSimWindow)
        # self.actionWczytaj.setObjectName("actionWczytaj")
        # self.actionZapisz = QtWidgets.QAction(RocketSimWindow)
        # self.actionZapisz.setObjectName("actionZapisz")
        self.actionWyj_cie = QAction(RocketSimWindow)
        self.actionWyj_cie.setObjectName("actionWyj_cie")
        self.actionWyj_cie.triggered.connect(self.quit)
        # self.menuSymulacja.addAction(self.actionZapisz)
        # self.menuSymulacja.addAction(self.actionWczytaj)
        self.menuSymulacja.addSeparator()
        self.menuSymulacja.addAction(self.actionWyj_cie)
        self.menuEdytor_poziom_w.addAction(self.actionSymulacja)
        self.menuEdytor_poziom_w.addAction(self.actionEdytor_Poziom_w)
        self.menubar.addAction(self.menuSymulacja.menuAction())
        self.menubar.addAction(self.menuEdytor_poziom_w.menuAction())
        oprogAct = QAction("O programie", self.centralwidget)
        oprogAct.triggered.connect(AboutWindow)
        self.menubar.addAction(oprogAct)

        self.retranslateUi(RocketSimWindow)
        QtCore.QMetaObject.connectSlotsByName(RocketSimWindow)

    def retranslateUi(self, RocketSimWindow):
        _translate = QtCore.QCoreApplication.translate
        RocketSimWindow.setWindowTitle(
            _translate("RocketSimWindow", "RocketSim"))
        self.pushButton.setText(_translate("RocketSimWindow", "Start"))
        self.label_3.setText(
            _translate("RocketSimWindow", "Stała grawitacji: "))
        self.label.setText(
            _translate("RocketSimWindow", "Kąt startu: " + str(Globals.angle)))
        self.label_2.setText(
            _translate("RocketSimWindow",
                       "Prędkość początkowa: " + str(Globals.init_v)))
        self.pushButton_2.setText(_translate("RocketSimWindow", "Stop"))
        self.menuSymulacja.setTitle(_translate("RocketSimWindow", "Plik"))
        self.menuEdytor_poziom_w.setTitle(
            _translate("RocketSimWindow", "Edycja"))
        self.actionSymulacja.setText(_translate("RocketSimWindow", "Planety"))
        self.actionEdytor_Poziom_w.setText(_translate("RocketSimWindow",
                                                      "---"))
        # self.actionWczytaj.setText(_translate("RocketSimWindow", "Wczytaj"))
        # self.actionZapisz.setText(_translate("RocketSimWindow", "Zapisz"))
        self.actionWyj_cie.setText(_translate("RocketSimWindow", "Wyjście"))
Beispiel #34
0
 def build_tray_menu(self):
     # Avoid immediate GC of old menu when window closed via its action
     if self.tray.contextMenu() is None:
         m = QMenu()
         self.tray.setContextMenu(m)
     else:
         m = self.tray.contextMenu()
         m.clear()
     network = self.daemon.network
     m.addAction(_("Network"), self.show_network_dialog)
     if network and network.lngossip:
         m.addAction(_("Lightning Network"), self.show_lightning_dialog)
     if network and network.local_watchtower:
         m.addAction(_("Local Watchtower"), self.show_watchtower_dialog)
     for window in self.windows:
         name = window.wallet.basename()
         submenu = m.addMenu(name)
         submenu.addAction(_("Show/Hide"), window.show_or_hide)
         submenu.addAction(_("Close"), window.close)
     m.addAction(_("Dark/Light"), self.toggle_tray_icon)
     m.addSeparator()
     m.addAction(_("Exit Electrum"), self.close)
Beispiel #35
0
 def contextMenuEvent(self, event):
     menu = QMenu()
     delete = menu.addAction('Delete')
     delete.triggered.connect(self.delete_connection)
     menu.exec_(event.screenPos())
Beispiel #36
0
class LayerListView(QListView):
    """
    Our own QListView derived class so we can handle the context menu event
    """
    def __init__(self):
        QListView.__init__(self)
        self.setSelectionMode(QAbstractItemView.ExtendedSelection)
        self.setupActions()
        self.setupMenu()

    def setupActions(self):
        "Set up the actions for the popup menu"
        self.layerExtentAct = QAction(self, triggered=self.zoomLayer)
        self.layerExtentAct.setText("&Zoom to Layer Extent")
        self.layerExtentAct.setStatusTip("Zoom to Layer Extent")
        self.layerExtentAct.setIcon(QIcon(":/viewer/images/zoomlayer.png"))
        self.layerExtentAct.setIconVisibleInMenu(True)

        self.removeLayerAct = QAction(self, triggered=self.removeLayers)
        self.removeLayerAct.setText("&Remove Selected Layer(s)")
        self.removeLayerAct.setStatusTip("Remove selected layer(s)")
        self.removeLayerAct.setIcon(QIcon(":/viewer/images/removelayer.png"))
        self.removeLayerAct.setIconVisibleInMenu(True)

        self.moveUpAct = QAction(self, triggered=self.moveUp)
        self.moveUpAct.setText("Move &Up")
        self.moveUpAct.setStatusTip("Move selected layer up in list")
        self.moveUpAct.setIcon(QIcon(":/viewer/images/arrowup.png"))
        self.moveUpAct.setIconVisibleInMenu(True)

        self.moveDownAct = QAction(self, triggered=self.moveDown)
        self.moveDownAct.setText("Move &Down")
        self.moveDownAct.setStatusTip("Move selected layer down in list")
        self.moveDownAct.setIcon(QIcon(":/viewer/images/arrowdown.png"))
        self.moveDownAct.setIconVisibleInMenu(True)

        self.moveToTopAct = QAction(self, triggered=self.moveToTop)
        self.moveToTopAct.setText("Move To &Top")
        self.moveToTopAct.setStatusTip("Move selected layer top top")

        self.changeColorAct = QAction(self, triggered=self.changeColor)
        self.changeColorAct.setText("Change &Color")
        self.changeColorAct.setStatusTip("Change color of vector layer")

        self.setSQLAct = QAction(self, triggered=self.setSQL)
        self.setSQLAct.setText("Set &attribute filter")
        self.setSQLAct.setStatusTip("Set attribute filter via SQL")

        self.setLineWidthAct = QAction(self, triggered=self.setLineWidth)
        self.setLineWidthAct.setText("Set &Line width")
        self.setLineWidthAct.setStatusTip(
            "Set line width of rendered features")

        self.setFillAct = QAction(self, toggled=self.toggleFill)
        self.setFillAct.setText("Fill Polygons")
        self.setFillAct.setStatusTip("Toggle the fill status of polygons")
        self.setFillAct.setCheckable(True)

        self.editStretchAct = QAction(self, triggered=self.editStretch)
        self.editStretchAct.setText("&Edit Stretch")
        self.editStretchAct.setStatusTip("Edit Stretch of raster layer")

        self.propertiesAct = QAction(self, triggered=self.properties)
        self.propertiesAct.setText("&Properties")
        self.propertiesAct.setStatusTip("Show properties of file")
        self.propertiesAct.setIcon(QIcon(":/viewer/images/properties.png"))
        self.propertiesAct.setIconVisibleInMenu(True)

    def setupMenu(self):
        "Create the popup menus"
        self.rasterPopupMenu = QMenu(self)
        self.rasterPopupMenu.addAction(self.layerExtentAct)
        self.rasterPopupMenu.addAction(self.removeLayerAct)
        self.rasterPopupMenu.addAction(self.moveUpAct)
        self.rasterPopupMenu.addAction(self.moveDownAct)
        self.rasterPopupMenu.addAction(self.moveToTopAct)
        self.rasterPopupMenu.addSeparator()
        self.rasterPopupMenu.addAction(self.editStretchAct)
        self.rasterPopupMenu.addAction(self.propertiesAct)

        self.vectorPopupMenu = QMenu(self)
        self.vectorPopupMenu.addAction(self.layerExtentAct)
        self.vectorPopupMenu.addAction(self.removeLayerAct)
        self.vectorPopupMenu.addAction(self.moveUpAct)
        self.vectorPopupMenu.addAction(self.moveDownAct)
        self.vectorPopupMenu.addAction(self.moveToTopAct)
        self.vectorPopupMenu.addSeparator()
        self.vectorPopupMenu.addAction(self.changeColorAct)
        self.vectorPopupMenu.addAction(self.setSQLAct)
        self.vectorPopupMenu.addAction(self.setLineWidthAct)
        self.vectorPopupMenu.addAction(self.setFillAct)
        self.vectorPopupMenu.addSeparator()
        self.vectorPopupMenu.addAction(self.propertiesAct)

    def contextMenuEvent(self, e):
        "Show our popup menu"
        selected = self.selectedIndexes()
        if len(selected) > 0:
            index = selected[0]

            model = self.model()
            layer = model.getLayer(index)
            if isinstance(layer, viewerlayers.ViewerVectorLayer):
                # sql gets enabled only if it is a full vector layer
                # - not a single feature layer
                allowSQL = not isinstance(
                    layer, viewerlayers.ViewerFeatureVectorLayer)
                self.setSQLAct.setEnabled(allowSQL)

                # get the existing state of the fill
                bFill = layer.getFill()
                self.setFillAct.setChecked(bFill)

                self.vectorPopupMenu.popup(e.globalPos())
            else:
                self.rasterPopupMenu.popup(e.globalPos())

    def zoomLayer(self):
        "zoom to the extents of the selected layer"
        selected = self.selectedIndexes()
        if len(selected) > 0:
            index = selected[0]

            model = self.model()
            layer = model.getLayer(index)
            extent = layer.coordmgr.getFullWorldExtent()
            layer.coordmgr.setWorldExtent(extent)
            model.viewwidget.layers.makeLayersConsistent(layer)
            model.viewwidget.layers.updateImages()
            model.viewwidget.viewport().update()

    def removeLayers(self):
        "remove the selected layer"
        try:
            selected = self.selectedIndexes()
        except AttributeError:
            # Layer windows is not open
            selected = []

        if len(selected) > 0:
            model = self.model()
            layers = [model.getLayer(layer) for layer in selected]

            model.viewwidget.removeLayers(layers)

    def moveUp(self):
        "Move the selected layer up in order"
        selected = self.selectedIndexes()
        if len(selected) > 0:
            index = selected[0]

            model = self.model()
            layer = model.getLayer(index)
            model.viewwidget.layers.moveLayerUp(layer)
            model.viewwidget.viewport().update()

    def moveDown(self):
        "Move the selected layer down in order"
        selected = self.selectedIndexes()
        if len(selected) > 0:
            index = selected[0]

            model = self.model()
            layer = model.getLayer(index)
            model.viewwidget.layers.moveLayerDown(layer)
            model.viewwidget.viewport().update()

    def moveToTop(self):
        "Move the selected layer to the top"
        selected = self.selectedIndexes()
        if len(selected) > 0:
            index = selected[0]

            model = self.model()
            layer = model.getLayer(index)
            model.viewwidget.layers.moveLayerToTop(layer)
            model.viewwidget.viewport().update()

    def changeColor(self):
        "Change the color of the vector layer"
        from PyQt5.QtWidgets import QColorDialog
        from PyQt5.QtGui import QColor
        selected = self.selectedIndexes()
        if len(selected) > 0:
            index = selected[0]

            model = self.model()
            layer = model.getLayer(index)

            rgba = layer.getColorAsRGBATuple()
            init = QColor(rgba[0], rgba[1], rgba[2], rgba[3])
            newCol = QColorDialog.getColor(init, self, "Choose Layer Color",
                                           QColorDialog.ShowAlphaChannel)
            if newCol.isValid():
                rgba = (newCol.red(), newCol.green(), newCol.blue(),
                        newCol.alpha())
                layer.updateColor(rgba)
                model.viewwidget.viewport().update()

    def setSQL(self):
        "Set the attribute filter for vector layers"
        from PyQt5.QtWidgets import QInputDialog
        selected = self.selectedIndexes()
        if len(selected) > 0:
            index = selected[0]

            model = self.model()
            layer = model.getLayer(index)

            oldsql = ""
            if layer.hasSQL():
                oldsql = layer.getSQL()

            sql, ok = QInputDialog.getText(self,
                                           MESSAGE_TITLE,
                                           "Enter SQL attribute filter",
                                           text=oldsql)
            if ok:
                if sql == "":
                    sql = None
                else:
                    sql = str(sql)
                layer.setSQL(sql)
                layer.getImage()
                model.viewwidget.viewport().update()

    def setLineWidth(self):
        "Set the line width for vector layers"
        from PyQt5.QtWidgets import QInputDialog
        selected = self.selectedIndexes()
        if len(selected) > 0:
            index = selected[0]

            model = self.model()
            layer = model.getLayer(index)

            linewidth = layer.getLineWidth()

            linewidth, ok = QInputDialog.getInt(self,
                                                MESSAGE_TITLE,
                                                "Enter line width",
                                                value=linewidth,
                                                min=1,
                                                max=100)
            if ok:
                layer.setLineWidth(linewidth)
                layer.getImage()
                model.viewwidget.viewport().update()

    def toggleFill(self, state):
        "toggle the fill state"
        selected = self.selectedIndexes()
        if len(selected) > 0:
            index = selected[0]

            model = self.model()
            layer = model.getLayer(index)
            layer.setFill(state)
            layer.getImage()
            model.viewwidget.viewport().update()

    def editStretch(self):
        "Edit the stretch for the layer"
        from . import stretchdialog
        selected = self.selectedIndexes()
        if len(selected) > 0:
            index = selected[0]

            model = self.model()
            layer = model.getLayer(index)

            stretchDock = stretchdialog.StretchDockWidget(
                self, model.viewwidget, layer)
            model.viewwindow.addDockWidget(Qt.TopDockWidgetArea, stretchDock)

    def properties(self):
        "Show the properties for the layer"
        from . import propertieswindow
        selected = self.selectedIndexes()
        if len(selected) > 0:
            index = selected[0]

            model = self.model()
            layer = model.getLayer(index)
            info = layer.getPropertiesInfo()
            dlg = propertieswindow.PropertiesWindow(self, info)
            dlg.setWindowTitle(layer.title)
            dlg.show()
class MultiProjectBrowser(QTreeWidget):
    """
    Class implementing the multi project browser.
    """
    def __init__(self, multiProject, parent=None):
        """
        Constructor
        
        @param multiProject reference to the multi project object
        @param parent parent widget (QWidget)
        """
        super(MultiProjectBrowser, self).__init__(parent)
        self.multiProject = multiProject

        self.setWindowIcon(UI.PixmapCache.getIcon("pymakr.png"))
        self.setAlternatingRowColors(True)
        self.setHeaderHidden(True)
        self.setItemsExpandable(False)
        self.setRootIsDecorated(False)
        self.setSortingEnabled(True)

        self.__openingProject = False

        self.multiProject.newMultiProject.connect(self.__newMultiProject)
        self.multiProject.multiProjectOpened.connect(self.__multiProjectOpened)
        self.multiProject.multiProjectClosed.connect(self.__multiProjectClosed)
        self.multiProject.projectDataChanged.connect(self.__projectDataChanged)
        self.multiProject.projectAdded.connect(self.__projectAdded)
        self.multiProject.projectRemoved.connect(self.__projectRemoved)
        self.multiProject.projectOpened.connect(self.__projectOpened)

        self.__createPopupMenu()
        self.setContextMenuPolicy(Qt.CustomContextMenu)
        self.customContextMenuRequested.connect(self.__contextMenuRequested)
        self.itemActivated.connect(self.__openItem)

        self.setEnabled(False)

    ###########################################################################
    ## Slot handling methods below
    ###########################################################################

    def __newMultiProject(self):
        """
        Private slot to handle the creation of a new multi project.
        """
        self.clear()
        self.setEnabled(True)

    def __multiProjectOpened(self):
        """
        Private slot to handle the opening of a multi project.
        """
        for project in self.multiProject.getProjects():
            self.__addProject(project)

        self.sortItems(0, Qt.AscendingOrder)

        self.setEnabled(True)

    def __multiProjectClosed(self):
        """
        Private slot to handle the closing of a multi project.
        """
        self.clear()
        self.setEnabled(False)

    def __projectAdded(self, project):
        """
        Private slot to handle the addition of a project to the multi project.
        
        @param project reference to the project data dictionary
        """
        self.__addProject(project)
        self.sortItems(0, Qt.AscendingOrder)

    def __projectRemoved(self, project):
        """
        Private slot to handle the removal of a project from the multi project.
        
        @param project reference to the project data dictionary
        """
        itm = self.__findProjectItem(project)
        if itm:
            parent = itm.parent()
            parent.removeChild(itm)
            del itm
            if parent.childCount() == 0:
                top = self.takeTopLevelItem(self.indexOfTopLevelItem(parent))
                del top

    def __projectDataChanged(self, project):
        """
        Private slot to handle the change of a project of the multi project.
        
        @param project reference to the project data dictionary
        """
        itm = self.__findProjectItem(project)
        if itm:
            parent = itm.parent()
            if parent.text(0) != project["category"]:
                self.__projectRemoved(project)
                self.__addProject(project)
            else:
                self.__setItemData(itm, project)

        self.sortItems(0, Qt.AscendingOrder)

    def __projectOpened(self, projectfile):
        """
        Private slot to handle the opening of a project.
        
        @param projectfile file name of the opened project file (string)
        """
        project = {
            'name': "",
            'file': projectfile,
            'master': False,
            'description': "",
            'category': "",
        }
        itm = self.__findProjectItem(project)
        if itm:
            itm.setSelected(True)

    def __contextMenuRequested(self, coord):
        """
        Private slot to show the context menu.
        
        @param coord the position of the mouse pointer (QPoint)
        """
        itm = self.itemAt(coord)
        if itm is None or itm.parent() is None:
            self.__backMenu.popup(self.mapToGlobal(coord))
        else:
            self.__menu.popup(self.mapToGlobal(coord))

    def __openItem(self, itm=None):
        """
        Private slot to open a project.
        
        @param itm reference to the project item to be opened (QTreeWidgetItem)
        """
        if itm is None:
            itm = self.currentItem()
            if itm is None or itm.parent() is None:
                return

        if not self.__openingProject:
            filename = itm.data(0, Qt.UserRole)
            if filename:
                self.__openingProject = True
                self.multiProject.openProject(filename)
                self.__openingProject = False

    ###########################################################################
    ## Private methods below
    ###########################################################################

    def __findCategoryItem(self, category):
        """
        Private method to find the item for a category.
        
        @param category category to search for (string)
        @return reference to the category item or None, if there is
            no such item (QTreeWidgetItem or None)
        """
        if category == "":
            category = self.tr("Not categorized")
        for index in range(self.topLevelItemCount()):
            itm = self.topLevelItem(index)
            if itm.text(0) == category:
                return itm

        return None

    def __addProject(self, project):
        """
        Private method to add a project to the list.
        
        @param project reference to the project data dictionary
        """
        parent = self.__findCategoryItem(project['category'])
        if parent is None:
            if project['category']:
                parent = QTreeWidgetItem(self, [project['category']])
            else:
                parent = QTreeWidgetItem(self, [self.tr("Not categorized")])
            parent.setExpanded(True)
        itm = QTreeWidgetItem(parent)
        self.__setItemData(itm, project)

    def __setItemData(self, itm, project):
        """
        Private method to set the data of a project item.
        
        @param itm reference to the item to be set (QTreeWidgetItem)
        @param project reference to the project data dictionary
        """
        itm.setText(0, project['name'])
        if project['master']:
            itm.setIcon(0, UI.PixmapCache.getIcon("masterProject.png"))
        else:
            itm.setIcon(0, UI.PixmapCache.getIcon("empty.png"))
        itm.setToolTip(0, project['file'])
        itm.setData(0, Qt.UserRole, project['file'])

    def __findProjectItem(self, project):
        """
        Private method to search a specific project item.
        
        @param project reference to the project data dictionary
        @return reference to the item (QTreeWidgetItem) or None
        """
        for topIndex in range(self.topLevelItemCount()):
            topItm = self.topLevelItem(topIndex)
            for childIndex in range(topItm.childCount()):
                itm = topItm.child(childIndex)
                data = itm.data(0, Qt.UserRole)
                if data == project['file']:
                    return itm

        return None

    def __removeProject(self):
        """
        Private method to handle the Remove context menu entry.
        """
        itm = self.currentItem()
        if itm is not None and itm.parent() is not None:
            filename = itm.data(0, Qt.UserRole)
            if filename:
                self.multiProject.removeProject(filename)

    def __showProjectProperties(self):
        """
        Private method to show the data of a project entry.
        """
        itm = self.currentItem()
        if itm is not None and itm.parent() is not None:
            filename = itm.data(0, Qt.UserRole)
            if filename:
                project = self.multiProject.getProject(filename)
                if project is not None:
                    from .AddProjectDialog import AddProjectDialog
                    dlg = AddProjectDialog(
                        self,
                        project=project,
                        categories=self.multiProject.getCategories())
                    if dlg.exec_() == QDialog.Accepted:
                        (name, filename, isMaster, description, category,
                         uid) = dlg.getData()
                        project = {
                            'name': name,
                            'file': filename,
                            'master': isMaster,
                            'description': description,
                            'category': category,
                            'uid': uid,
                        }
                        self.multiProject.changeProjectProperties(project)

    def __addNewProject(self):
        """
        Private method to add a new project entry.
        """
        self.multiProject.addProject()

    def __createPopupMenu(self):
        """
        Private method to create the popup menu.
        """
        self.__menu = QMenu(self)
        self.__menu.addAction(self.tr("Open"), self.__openItem)
        self.__menu.addAction(self.tr("Remove"), self.__removeProject)
        self.__menu.addAction(self.tr("Properties"),
                              self.__showProjectProperties)
        self.__menu.addSeparator()
        self.__menu.addAction(self.tr("Add Project..."), self.__addNewProject)
        self.__menu.addSeparator()
        self.__menu.addAction(self.tr("Configure..."), self.__configure)

        self.__backMenu = QMenu(self)
        self.__backMenu.addAction(self.tr("Add Project..."),
                                  self.__addNewProject)
        self.__backMenu.addSeparator()
        self.__backMenu.addAction(self.tr("Configure..."), self.__configure)

    def __configure(self):
        """
        Private method to open the configuration dialog.
        """
        e5App().getObject("UserInterface").showPreferences("multiProjectPage")
Beispiel #38
0
 def create_menu(self, position):
     wallet = self.parent.wallet
     items = self.selected_in_column(0)
     if len(items) > 1:
         keys = [item.data(ROLE_REQUEST_ID) for item in items]
         invoices = [wallet.invoices.get(key) for key in keys]
         can_batch_pay = all([
             i.type == PR_TYPE_ONCHAIN
             and wallet.get_invoice_status(i) == PR_UNPAID for i in invoices
         ])
         menu = QMenu(self)
         if can_batch_pay:
             menu.addAction(
                 _("Batch pay invoices"),
                 lambda: self.parent.pay_multiple_invoices(invoices))
         menu.addAction(_("Delete invoices"),
                        lambda: self.parent.delete_invoices(keys))
         menu.exec_(self.viewport().mapToGlobal(position))
         return
     idx = self.indexAt(position)
     item = self.item_from_index(idx)
     item_col0 = self.item_from_index(
         idx.sibling(idx.row(), self.Columns.DATE))
     if not item or not item_col0:
         return
     key = item_col0.data(ROLE_REQUEST_ID)
     invoice = self.parent.wallet.get_invoice(key)
     menu = QMenu(self)
     self.add_copy_menu(menu, idx)
     if invoice.is_lightning():
         menu.addAction(_("Details"),
                        lambda: self.parent.show_lightning_invoice(invoice))
     else:
         if len(invoice.outputs) == 1:
             menu.addAction(
                 _("Copy Address"),
                 lambda: self.parent.do_copy(invoice.get_address(),
                                             title='Bitcoin Address'))
         menu.addAction(_("Details"),
                        lambda: self.parent.show_onchain_invoice(invoice))
     status = wallet.get_invoice_status(invoice)
     if status == PR_UNPAID:
         menu.addAction(_("Pay"),
                        lambda: self.parent.do_pay_invoice(invoice))
     if status == PR_FAILED:
         menu.addAction(_("Retry"),
                        lambda: self.parent.do_pay_invoice(invoice))
     if self.parent.wallet.lnworker:
         log = self.parent.wallet.lnworker.logs.get(key)
         if log:
             menu.addAction(_("View log"), lambda: self.show_log(key, log))
     menu.addAction(_("Delete"), lambda: self.parent.delete_invoices([key]))
     menu.exec_(self.viewport().mapToGlobal(position))
Beispiel #39
0
 def contextMenuEvent(self, e):
     context = QMenu(self)
     context.addAction(QAction("test 1", self))
     context.addAction(QAction("test 2", self))
     context.addAction(QAction("test 3", self))
     context.exec(e.globalPos())
Beispiel #40
0
class StepListView:
    def __init__(self, main_window):
        self.main_window = main_window
        self.lst_steps: CustomStepsListView = self.main_window.lst_steps
        self.controller = StepListController(self, self.main_window.world)

        # menu
        delete_action = QAction("Delete", self.lst_steps)
        delete_action.triggered.connect(self.on_delete_selected_item)

        self.menu = QMenu()
        self.menu.addAction(delete_action)

        # setup model
        self.model = QStandardItemModel()
        self.lst_steps.setModel(self.model)
        self.lst_steps.setItemDelegate(StepItemDelegate())

        # ui events
        self.lst_steps.selectionModel().currentChanged.connect(
            self.on_step_selected)
        self.lst_steps.setContextMenuPolicy(Qt.CustomContextMenu)
        self.lst_steps.customContextMenuRequested.connect(
            self.on_display_context_menu)
        self.lst_steps.dropEventSignal.connect(self.on_drop_event)

    def on_drop_event(self, model_index: QModelIndex):
        selected_model_indexes = self.lst_steps.selectedIndexes()
        self.delete_steps_by_indexes(selected_model_indexes,
                                     delete_from_db=False)

        def step_with_order(order):
            step_entity = self.model.item(order).data(STEP_LIST_OBJECT_ROLE)
            step_entity.order = order
            return step_entity

        steps = [step_with_order(n) for n in range(self.model.rowCount())]
        self.controller.update_multiple_steps(steps)

    def get_step_entity_at_index(self, model_index):
        return model_index.data(STEP_LIST_OBJECT_ROLE)

    def select_step_at_index(self, model_index):
        self.lst_steps.setCurrentIndex(model_index)

    def indexes_for_selected_rows(self):
        return self.lst_steps.selectedIndexes()

    def delete_steps_by_indexes(self, model_indexes, delete_from_db=True):
        for items in reversed(sorted(model_indexes)):
            if delete_from_db:
                step_entity: StepEntity = self.get_step_entity_at_index(items)
                self.controller.delete_step(step_entity)
            self.model.takeRow(items.row())

    def on_delete_selected_item(self):
        selected_model_indexes = self.indexes_for_selected_rows()
        if not selected_model_indexes:
            return

        self.delete_steps_by_indexes(selected_model_indexes)

        before_first_row_to_delete = selected_model_indexes[0].row() - 1
        if before_first_row_to_delete >= 0:
            previous_item: QStandardItem = self.model.item(
                before_first_row_to_delete)
            if previous_item:
                self.select_step_at_index(previous_item.index())

    def on_display_context_menu(self, position):
        index: QModelIndex = self.lst_steps.indexAt(position)
        if not index.isValid():
            return

        global_position = self.lst_steps.viewport().mapToGlobal(position)
        self.menu.exec_(global_position)

    def clear_steps(self):
        self.model.clear()

    def update_steps(self, steps):
        for step in steps:
            self.add_step_widget(step, select_item=False)

    def select_step_at(self, position):
        first_item: QStandardItem = self.model.item(position)
        self.lst_steps.setCurrentIndex(first_item.index())

    def add_step_widget(self, step: StepEntity, select_item=True):
        logging.info("Adding a new widget for {}".format(step))
        step_item = QStandardItem("({}) {}".format(step.step_type.value,
                                                   step.title))
        step_item.setData(step, STEP_LIST_OBJECT_ROLE)
        step_item.setData(QVariant(step.id), STEP_LIST_ID_ROLE)
        step_item.setDragEnabled(True)
        step_item.setDropEnabled(False)
        self.model.appendRow(step_item)

        if select_item:
            index = self.model.indexFromItem(step_item)
            self.lst_steps.setCurrentIndex(index)

    def on_step_selected(self, current: QModelIndex):
        if not current:
            return

        selected_step_id = current.data(STEP_LIST_ID_ROLE)
        self.controller.trigger_step_selected(selected_step_id)
Beispiel #41
0
    def create_menu(self, position):
        menu = QMenu()
        selected = self.selectedItems()
        if not selected:
            menu.addAction(_("New contact"),
                           lambda: self.parent.new_contact_dialog())
            menu.addAction(_("Import file"), lambda: self.import_contacts())
            menu.addAction(_("Export file"), lambda: self.export_contacts())
        else:
            names = [item.text(0) for item in selected]
            keys = [item.text(1) for item in selected]
            column = self.currentColumn()
            column_title = self.headerItem().text(column)
            column_data = '\n'.join([item.text(column) for item in selected])
            menu.addAction(
                _("Copy {}").format(column_title),
                lambda: self.parent.app.clipboard().setText(column_data))
            if column in self.editable_columns:
                item = self.currentItem()
                menu.addAction(
                    _("Edit {}").format(column_title),
                    lambda: self.editItem(item, column))
            menu.addAction(_("Pay to"),
                           lambda: self.parent.payto_contacts(keys))
            menu.addAction(_("Delete"),
                           lambda: self.parent.delete_contacts(keys))
            URLs = [
                block_explorer_URL(self.config, 'addr', key)
                for key in filter(is_address, keys)
            ]
            if URLs:
                menu.addAction(_("View on block explorer"),
                               lambda: map(webbrowser.open, URLs))

        run_hook('create_contact_menu', menu, selected)
        menu.exec_(self.viewport().mapToGlobal(position))
    def create_menu(self, position: QPoint):
        org_idx: QModelIndex = self.indexAt(position)
        idx = self.proxy.mapToSource(org_idx)
        if not idx.isValid():
            # can happen e.g. before list is populated for the first time
            return
        tx_item = self.hm.transactions.value_from_pos(idx.row())
        column = idx.column()
        if column == DiceHistoryColumns.STATUS_ICON:
            column_title = _('Transaction ID')
            column_data = tx_item['txid']
        else:
            column_title = self.hm.headerData(column, Qt.Horizontal,
                                              Qt.DisplayRole)
            column_data = self.hm.data(idx, Qt.DisplayRole).value()
        tx_hash = tx_item['txid']
        tx = self.wallet.db.get_transaction(tx_hash)
        if not tx:
            return
        tx_URL = block_explorer_URL(self.config, 'tx', tx_hash)
        height = self.wallet.get_tx_height(tx_hash).height
        is_relevant, is_mine, v, fee = self.wallet.get_wallet_delta(tx)
        is_unconfirmed = height <= 0
        pr_key = self.wallet.invoices.paid.get(tx_hash)
        menu = QMenu()
        if height == TX_HEIGHT_LOCAL:
            menu.addAction(_("Remove"), lambda: self.remove_local_tx(tx_hash))

        amount_columns = [
            DiceHistoryColumns.COIN_VALUE,
            DiceHistoryColumns.RUNNING_COIN_BALANCE,
            DiceHistoryColumns.FIAT_VALUE, DiceHistoryColumns.FIAT_ACQ_PRICE,
            DiceHistoryColumns.FIAT_CAP_GAINS
        ]
        if column in amount_columns:
            column_data = column_data.strip()
        menu.addAction(
            _("Copy {}").format(column_title),
            lambda: self.parent.app.clipboard().setText(str(column_data)))

        for c in self.editable_columns:
            if c is None or self.isColumnHidden(c): continue
            label = self.hm.headerData(c, Qt.Horizontal, Qt.DisplayRole)
            # TODO use siblingAtColumn when min Qt version is >=5.11
            persistent = QPersistentModelIndex(
                org_idx.sibling(org_idx.row(), c))
            menu.addAction(_("Edit {}").format(label),
                           lambda p=persistent: self.edit(QModelIndex(p)))
        menu.addAction(
            _("Copy result hash"), lambda: self.parent.app.clipboard().setText(
                tx_item['resultBlockHash']))
        menu.addAction(_("View Bet Tx details"),
                       lambda: self.show_transaction(tx_hash))

        if is_unconfirmed and tx:
            # note: the current implementation of RBF *needs* the old tx fee
            rbf = is_mine and not tx.is_final() and fee is not None
            if rbf:
                menu.addAction(_("Increase fee"),
                               lambda: self.parent.bump_fee_dialog(tx))
            else:
                child_tx = self.wallet.cpfp(tx, 0)
                if child_tx:
                    menu.addAction(_("Child pays for parent"),
                                   lambda: self.parent.cpfp(tx, child_tx))
        if pr_key:
            menu.addAction(read_QIcon("seal"), _("View invoice"),
                           lambda: self.parent.show_invoice(pr_key))
        if tx_URL:
            menu.addAction(_("View on block explorer"),
                           lambda: webopen(tx_URL))
        menu.exec_(self.viewport().mapToGlobal(position))
Beispiel #43
0
    def __init__(self, app, latus_appdata_folder, parent=None):
        latus.logger.log.info('starting LatusSystemTrayIcon')
        self.app = app

        from latus import icons
        icon = QIcon(QPixmap(':active.png'))
        super().__init__(icon, parent)
        self.latus_appdata_folder = latus_appdata_folder

        menu = QMenu(parent)
        menu.addAction("Open Latus Folder").triggered.connect(self.open_latus_folder)
        menu.addSeparator()
        menu.addAction("Preferences").triggered.connect(self.preferences)

        # Generally importing of a latus key should be done during initial setup.  It's dangerous to change the
        # key while running.  So, for now anyway, let's not even give the option to the user.
        # menu.addAction("Import Latus Key").triggered.connect(self.import_latus_key)

        menu.addAction("Export Latus Key").triggered.connect(self.export_latus_key)
        menu.addSeparator()
        menu.addAction("About").triggered.connect(self.about)
        menu.addAction("Nodes").triggered.connect(self.nodes)
        menu.addAction("Advanced").triggered.connect(self.advanced)
        menu.addSeparator()
        menu.addAction("Exit").triggered.connect(self.exit)
        self.setContextMenu(menu)

        self.sync = None
Beispiel #44
0
 def create_menu(self, position):
     idx = self.indexAt(position)
     item = self.model().itemFromIndex(idx)
     # TODO use siblingAtColumn when min Qt version is >=5.11
     item = self.model().itemFromIndex(
         idx.sibling(idx.row(), self.Columns.DATE))
     if not item:
         return
     key = item.data(ROLE_KEY)
     request_type = item.data(ROLE_REQUEST_TYPE)
     req = self.wallet.get_request(key)
     if req is None:
         self.update()
         return
     column = idx.column()
     column_title = self.model().horizontalHeaderItem(column).text()
     column_data = self.model().itemFromIndex(idx).text()
     menu = QMenu(self)
     if column == self.Columns.AMOUNT:
         column_data = column_data.strip()
     menu.addAction(
         _("Copy {}").format(column_title),
         lambda: self.parent.do_copy(column_title, column_data))
     if request_type == PR_TYPE_ADDRESS:
         menu.addAction(_("Copy Address"),
                        lambda: self.parent.do_copy('Address', key))
     if request_type == PR_TYPE_LN:
         menu.addAction(
             _("Copy lightning payment request"),
             lambda: self.parent.do_copy('Request', req['invoice']))
     else:
         menu.addAction(_("Copy URI"),
                        lambda: self.parent.do_copy('URI', req['URI']))
     if 'http_url' in req:
         menu.addAction(_("View in web browser"),
                        lambda: webopen(req['http_url']))
     # do bip70 only for browser access
     # so, each request should have an ID, regardless
     #menu.addAction(_("Save as BIP70 file"), lambda: self.parent.export_payment_request(addr))
     menu.addAction(_("Delete"), lambda: self.parent.delete_request(key))
     run_hook('receive_list_menu', menu, key)
     menu.exec_(self.viewport().mapToGlobal(position))
Beispiel #45
0
    def contextMenuEvent(self, event):
        '''
        上下文菜单的函数,与上期相同部分,不注释。
        '''
        hitIndex = self.indexAt(event.pos()).column()
        if hitIndex > -1:
            pmenu = QMenu(self)
            pDeleteAct = QAction("删除", pmenu)
            pmenu.addAction(pDeleteAct)
            pDeleteAct.triggered.connect(self.deleteItemSlot)
            if self is self.find('我的好友'):
                pAddItem = QAction("新增好友", pmenu)
                pmenu.addAction(pAddItem)     
                pAddItem.triggered.connect(self.addItemSlot)
            # 判断一下是否在“我的好友”这个分组单击右键的,否则不会产生新增好友的菜单。

            if len(self.map_listwidget) > 1:
                pSubMenu = QMenu("转移联系人至", pmenu)
                pmenu.addMenu(pSubMenu)
                for item_dic in self.map_listwidget:
                    if item_dic['listwidget'] is not self:
                        # 在遍历分组名称和QListWidget对象字典的时候,会判断下当前要转移的分组是否就是单击右键时分组。
                        pMoveAct = QAction(item_dic['groupname'], pmenu)
                        pSubMenu.addAction(pMoveAct)
                        pMoveAct.triggered.connect(self.move)
            pmenu.popup(self.mapToGlobal(event.pos()))
Beispiel #46
0
    def show_pkg_actions(self, pkg: PackageView):
        menu_row = QMenu()
        menu_row.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Preferred)
        menu_row.setObjectName('app_actions')
        menu_row.setCursor(QCursor(Qt.PointingHandCursor))

        if pkg.model.installed:

            if pkg.model.has_history():
                def show_history():
                    self.window.begin_show_history(pkg)

                menu_row.addAction(QCustomMenuAction(parent=menu_row,
                                                     label=self.i18n["manage_window.apps_table.row.actions.history"],
                                                     action=show_history,
                                                     button_name='app_history'))

            if pkg.model.can_be_downgraded():

                def downgrade():
                    if ConfirmationDialog(title=self.i18n['manage_window.apps_table.row.actions.downgrade'],
                                          body=self._parag(self.i18n[
                                                               'manage_window.apps_table.row.actions.downgrade.popup.body'].format(
                                              self._bold(str(pkg)))),
                                          i18n=self.i18n).ask():
                        self.window.begin_downgrade(pkg)

                menu_row.addAction(QCustomMenuAction(parent=menu_row,
                                                     label=self.i18n["manage_window.apps_table.row.actions.downgrade"],
                                                     action=downgrade,
                                                     button_name='app_downgrade'))

            if pkg.model.supports_ignored_updates():
                if pkg.model.is_update_ignored():
                    action_label = self.i18n["manage_window.apps_table.row.actions.ignore_updates_reverse"]
                    button_name = 'revert_ignore_updates'
                else:
                    action_label = self.i18n["manage_window.apps_table.row.actions.ignore_updates"]
                    button_name = 'ignore_updates'

                def ignore_updates():
                    self.window.begin_ignore_updates(pkg)

                menu_row.addAction(QCustomMenuAction(parent=menu_row,
                                                     label=action_label,
                                                     button_name=button_name,
                                                     action=ignore_updates))

        if bool(pkg.model.get_custom_supported_actions()):
            actions = [self._map_custom_action(pkg, a, menu_row) for a in pkg.model.get_custom_supported_actions()]
            menu_row.addActions(actions)

        menu_row.adjustSize()
        menu_row.popup(QCursor.pos())
        menu_row.exec_()
Beispiel #47
0
 def _on_exports_contextmenu(self, pos):
     """ ExportsList ContextMenu
     """
     index = self.exports_list.indexAt(pos).row()
     if index != -1:
         glbl_pt = self.exports_list.mapToGlobal(pos)
         context_menu = QMenu(self)
         func_name = self.exports_model.item(index, 0).text()
         addr = self.exports_model.item(index, 1).text()
         context_menu.addAction(
             'Add Hook', lambda: self._add_hook(addr, func_name))
         context_menu.addSeparator()
         context_menu.addAction(
             'Copy address', lambda: utils.copy_hex_to_clipboard(
                 self.exports_model.item(index, 1).text()))
         context_menu.addSeparator()
         context_menu.addAction(
             'Copy FunctionName', lambda: utils.copy_str_to_clipboard(
                 func_name))
         context_menu.exec_(glbl_pt)
Beispiel #48
0
    def show_context_menu(self, pos):
        global_pos = self.mapToGlobal(pos)

        selected = self.selected_files()
        menu = QMenu(self)

        action = menu.addAction(_("ACTION_FILE_OPEN_CURRENT_DIRECTORY"))
        action.triggered.connect(self.open_current_dir_clicked.emit)
        if len(selected):
            action = menu.addAction(_("ACTION_FILE_MENU_OPEN"))
            action.triggered.connect(self.open_clicked.emit)
            if not self.is_read_only():
                action = menu.addAction(_("ACTION_FILE_MENU_RENAME"))
                action.triggered.connect(self.rename_clicked.emit)
                action = menu.addAction(_("ACTION_FILE_MENU_DELETE"))
                action.triggered.connect(self.delete_clicked.emit)
                action = menu.addAction(_("ACTION_FILE_MENU_COPY"))
                action.triggered.connect(self.copy_clicked.emit)
                action = menu.addAction(_("ACTION_FILE_MENU_CUT"))
                action.triggered.connect(self.cut_clicked.emit)
        if len(selected) == 1:
            action = menu.addAction(_("ACTION_FILE_MENU_SHOW_FILE_HISTORY"))
            action.triggered.connect(self.show_history_clicked.emit)
            action = menu.addAction(_("ACTION_FILE_MENU_GET_FILE_LINK"))
            action.triggered.connect(self.file_path_clicked.emit)
        if not self.is_read_only():
            if self.paste_status.source_workspace:
                action = menu.addAction(
                    _("ACTION_FILE_MENU_PASTE_FROM_OTHER_WORKSPACE_source").
                    format(source=self.paste_status.source_workspace))
            else:
                action = menu.addAction(_("ACTION_FILE_MENU_PASTE"))
            action.triggered.connect(self.paste_clicked.emit)
            if self.paste_status.status == PasteStatus.Status.Disabled:
                action.setDisabled(True)
        menu.exec_(global_pos)
Beispiel #49
0
 def create_menu(self, position):
     idx = self.indexAt(position)
     item = self.model().itemFromIndex(idx)
     item_col0 = self.model().itemFromIndex(
         idx.sibling(idx.row(), self.Columns.DATE))
     if not item or not item_col0:
         return
     key = item_col0.data(ROLE_REQUEST_ID)
     request_type = item_col0.data(ROLE_REQUEST_TYPE)
     menu = QMenu(self)
     self.add_copy_menu(menu, idx)
     invoice = self.parent.wallet.get_invoice(key)
     menu.addAction(_("Details"), lambda: self.parent.show_invoice(key))
     if invoice['status'] == PR_UNPAID:
         menu.addAction(_("Pay"),
                        lambda: self.parent.do_pay_invoice(invoice))
     if key in self.logs:
         menu.addAction(_("View log"), lambda: self.show_log(key))
     menu.addAction(_("Delete"), lambda: self.parent.delete_invoice(key))
     menu.exec_(self.viewport().mapToGlobal(position))
Beispiel #50
0
 def create_menu(self, position):
     menu = QMenu()
     idx = self.selectionModel().currentIndex()
     item = self.model().itemFromIndex(idx)
     if not item:
         return
     channel_id = idx.sibling(idx.row(),
                              self.Columns.NODE_ID).data(ROLE_CHANNEL_ID)
     chan = self.lnworker.channels[channel_id]
     menu.addAction(_("Details..."), lambda: self.details(channel_id))
     self.add_copy_menu(menu, idx)
     if not chan.is_closed():
         menu.addAction(_("Close channel"),
                        lambda: self.close_channel(channel_id))
         menu.addAction(_("Force-close channel"),
                        lambda: self.force_close(channel_id))
     else:
         menu.addAction(_("Remove"),
                        lambda: self.remove_channel(channel_id))
     menu.exec_(self.viewport().mapToGlobal(position))
Beispiel #51
0
    def _on_modules_contextmenu(self, pos):
        """ Modules ContextMenu
        """
        index = self.modules_list.indexAt(pos).row()
        glbl_pt = self.modules_list.mapToGlobal(pos)
        context_menu = QMenu(self)
        if index != -1:
            context_menu.addAction(
                'Dump Binary', lambda: self._on_dumpmodule(
                    self.modules_model.item(index, 1).text(),
                    self.modules_model.item(index, 2).text()))
            context_menu.addAction(
                'Copy address', lambda: utils.copy_hex_to_clipboard(
                    self.modules_model.item(index, 1).text()))
            context_menu.addSeparator()
            context_menu.addAction(
                'Copy Name', lambda: utils.copy_str_to_clipboard(
                    self.modules_model.item(index, 0).text()))
            context_menu.addAction(
                'Copy Path', lambda: utils.copy_str_to_clipboard(
                    self.modules_model.item(index, 3).text()))
            context_menu.addSeparator()

        context_menu.addAction('Refresh', self.update_modules)
        context_menu.exec_(glbl_pt)
Beispiel #52
0
class CMainWindow(QtWidgets.QDialog):
    def __init__(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        super(CMainWindow, self).__init__()
        uic.loadUi('encfsgui_main.ui', self)

        # disable/remove buttons
        self.setWindowFlags(self.windowFlags() | QtCore.Qt.CustomizeWindowHint | QtCore.Qt.WindowStaysOnTopHint)
        self.setWindowFlag(QtCore.Qt.WindowMaximizeButtonHint, False)
        self.setWindowFlag(QtCore.Qt.WindowCloseButtonHint, False)

        # assign methods to buttons
        self.quitbutton =  self.findChild(QtWidgets.QToolButton, 'btn_Quit')
        self.quitbutton.clicked.connect(self.QuitButtonClicked)

        self.hidebutton = self.findChild(QtWidgets.QToolButton, 'btn_Hide')
        self.hidebutton.clicked.connect(self.HideButtonClicked)

        self.createvolumebutton = self.findChild(QtWidgets.QToolButton, 'btn_createVolume')
        self.createvolumebutton.clicked.connect(self.CreateVolumeButtonClicked)

        self.addvolumebutton = self.findChild(QtWidgets.QToolButton, 'btn_openVolume')
        self.addvolumebutton.clicked.connect(self.AddVolumeButtonClicked)

        self.editvolumebutton = self.findChild(QtWidgets.QToolButton, 'btn_editVolume')
        self.editvolumebutton.clicked.connect(self.EditVolumeButtonClicked)

        self.settingsbutton = self.findChild(QtWidgets.QToolButton, 'btn_Settings')
        self.settingsbutton.clicked.connect(self.SetttingsButtonClicked)

        self.volumetable = self.findChild(QtWidgets.QTableWidget, 'tbl_Volumes')
        self.volumetable.itemSelectionChanged.connect(self.TableEntrySelected)

        self.browsevolumebutton = self.findChild(QtWidgets.QToolButton, 'btn_browseVolume')
        self.browsevolumebutton.clicked.connect(self.BrowseVolumeClicked)
        
        self.removevolumebutton = self.findChild(QtWidgets.QToolButton, 'btn_removeVolume')
        self.removevolumebutton.clicked.connect(self.RemoveVolumeClicked)

        self.infovolumebutton = self.findChild(QtWidgets.QToolButton, 'btn_infoVolume')
        self.infovolumebutton.clicked.connect(self.ShowVolumeInfoClicked)

        self.refreshbutton = self.findChild(QtWidgets.QToolButton, 'btn_refreshVolumes')
        self.refreshbutton.clicked.connect(self.RefreshVolumesClicked)
        
        self.mountvolumebutton = self.findChild(QtWidgets.QToolButton, 'btn_mountVolume')
        self.mountvolumebutton.clicked.connect(self.MountVolumeClicked)

        self.unmountvolumebutton = self.findChild(QtWidgets.QToolButton, 'btn_unmountVolume')
        self.unmountvolumebutton.clicked.connect(self.UnmountVolumeClicked)

        self.unmountallbutton = self.findChild(QtWidgets.QToolButton, 'btn_unmountAll')
        self.unmountallbutton.clicked.connect(self.UnmountAllClicked)

        self.lbl_updatestate = self.findChild(QtWidgets.QLabel, 'lbl_updatestate')
        self.lbl_updatestate.setText("")

        self.lbl_infolabel = self.findChild(QtWidgets.QLabel, 'lbl_InfoLabel')
        self.lbl_infolabel.setText("")


    def initMainWindow(self):
        # only call this after checking for update
        # enable/disablebuttons as needed
        self.RefreshSettings()
        self.RefreshVolumes()
        self.EnableDisableButtons()
        
        # system tray menu
        self.tray_icon = QSystemTrayIcon(self)
        #self.tray_icon.setIcon(self.style().standardIcon(QStyle.SP_DriveHDIcon))
        #self.tray_icon.setIcon(QIcon('./bitmaps/encfsgui.png'))
        icondir = encfsgui_helper.getCurDir()
        iconfolder = os.path.join(icondir,'bitmaps' )
        iconpath = os.path.join(iconfolder, 'encfsgui.ico')
        wiconpath = os.path.join(iconfolder, 'encfsgui.png')
        self.tray_icon.setIcon(QIcon(iconpath))
        self.tray_icon.setVisible(True)
        self.tray_menu = QMenu()
        self.volume_menu = QMenu()
        self.CreateTrayMenu()

        self.setWindowIcon(QIcon(wiconpath))

        # context menu for TableWidget
        self.volumetable = self.findChild(QtWidgets.QTableWidget, 'tbl_Volumes')
        self.volumetablemenu = QMenu()
        self.volumetable.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self.volumetable.customContextMenuRequested.connect(self.CreateVolumeMenu)
        # capture right click
        self.volumetable.viewport().installEventFilter(self)
        # capture double click
        self.volumetable.doubleClicked.connect(self.TableDoubleClicked)


    def eventFilter(self, source, event):
        if(event.type() == QtCore.QEvent.MouseButtonPress and
           event.buttons() == QtCore.Qt.RightButton and
           source is self.volumetable.viewport()):
            item = self.volumetable.itemAt(event.pos())
            encfsgui_helper.print_debug('Right-click at Global Pos: %s' % event.globalPos())
            if item is not None:
                encfsgui_helper.print_debug('Right-click Table Item: %s %s' % (item.row(), item.column()))
                encfsgui_helper.print_debug('Currently selected volume: %s' % encfsgui_globals.g_CurrentlySelected)
                self.CreateVolumeMenu()
                self.volumetablemenu.exec_(event.globalPos())
                #menu.exec_(event.globalPos())
        return super(CMainWindow, self).eventFilter(source, event)


    # table double click
    def TableDoubleClicked(self):
        if encfsgui_globals.g_Settings["doubleclickmount"].lower() == "true":
            if encfsgui_globals.g_CurrentlySelected != "":
                volumename = encfsgui_globals.g_CurrentlySelected
                if volumename in encfsgui_globals.g_Volumes:
                    EncVolumeObj = encfsgui_globals.g_Volumes[volumename]
                    if EncVolumeObj.ismounted:
                        self.UnmountVolumeClicked()
                    else:
                        self.MountVolumeClicked()
        return

    #methods linked to buttons
    def QuitButtonClicked(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        doexit = False
        autunmount = False
        if "autounmount" in encfsgui_globals.g_Settings:
            if str(encfsgui_globals.g_Settings["autounmount"]) == "true":
                autunmount = True
        if "noconfirmationexit" in encfsgui_globals.g_Settings:
            if str(encfsgui_globals.g_Settings["noconfirmationexit"]) == "false":
                msgBox = QMessageBox()
                msgBox.setIcon(QMessageBox.Question)
                msgBox.setWindowTitle("Please confirm?")
                if autunmount:
                    msgBox.setText("Are you sure you would like to exit?\n\nPlease note that some volumes may be unmounted automatically when you exit the application, so please make sure all files are closed.")
                else:
                    msgBox.setText("Are you sure you would like to exit?")
                msgBox.setStandardButtons(QtWidgets.QMessageBox.No)
                msgBox.addButton(QtWidgets.QMessageBox.Yes)
                msgBox.show()
                msgBox.setFocus()
                if (msgBox.exec_() == QtWidgets.QMessageBox.Yes):
                    doexit = True
            else:
                doexit = True

        if doexit:
            self.AutoUnMount()
            encfsgui_helper.print_debug("Application has exited.")
            sys.exit(0)
        return

    def ShowButtonClicked(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        self.show_action.setEnabled(False)
        self.hide_action.setEnabled(True)
        encfsgui_globals.ishidden = False
        self.show()
        # force reload of modules and update window
        self.lbl_infolabel.setText("")
        self.volumetable.clearContents()
        self.volumetable.setRowCount(0)
        encfsgui_globals.appconfig.getVolumes()
        self.RefreshVolumes()
        self.PopulateVolumeMenu()
        self.setFocus()
        return

    def HideButtonClicked(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        self.show_action.setEnabled(True)
        self.hide_action.setEnabled(False)
        if encfsgui_globals.g_Settings["clearkeywhenhidden"].lower() == "true":
            print_debug("Hiding window, clearing masterkey")
            encfsgui_globals.masterkey = ""
        encfsgui_globals.ishidden = True
        self.PopulateVolumeMenu()   # will disable menu if needed
        # only hide on macos
        try:
            if encfsgui_helper.ismacOS():
                self.hide()
            elif encfsgui_helper.isLinux():
                self.showMinimized()
        except Exception as e:
            print_debug("Error hiding/minimizing: %s" % str(e))
        return

    def AboutClicked(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        abouttext = "pyencfsgui (EncFSGui) is a python3/PyQT5 based GUI wrapper around encfs and/or gocryptfs.\n\n"
        abouttext += "This version has been tested with encfs 1.9.x on OSX Catalina (and newer macOS versions), \n"
        abouttext += "and with gocryptfs 1.8.x on OSX Big Sur (and newer macOS versions). \n"
        abouttext += "Additionally, EncFSGui has been confirmed to work in Kali Linux.\n\n"
        abouttext += "Development started in 2019. The utility was written by Peter 'corelanc0d3r' Van Eeckhoutte.\n"
        abouttext += "Corelan Consulting bv\nwww.corelan-consulting.com | www.corelan-training.com\n\n"
        abouttext += "Project repository:\nhttps://github.com/corelan/pyencfsgui\n\n"
        abouttext += "Version info:\n"
        abouttext += "EncFSGui version %s.\n" % encfsgui_helper.getVersion()

        if os.path.exists(encfsgui_globals.g_Settings["encfspath"]):
            abouttext +=  "encfs version %s.\n" % getEncFSVersion()
        else:
            abouttext +=  "encfs not found.\n"
        
        if os.path.exists(encfsgui_globals.g_Settings["gocryptfspath"]):
            abouttext +=  "gocryptfs version %s.\n\n" % getGoCryptFSVersion()
        else:
            abouttext +=  "gocryptfs not found.\n\n"
        
        abouttext +=  "This application uses icons from https://icons8.com.\n"
        abouttext +=  "\nYou are running %s" % encfsgui_helper.getOSType()

        msgBox = QMessageBox()
        msgBox.setWindowTitle("About pyencfsgui")
        msgBox.setText(abouttext)
        msgBox.show()
        msgBox.exec_()
        return

    def checkFilenameEncodings(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        encfsgui_helper.print_debug("Encodings: %s" % encfsgui_globals.g_Encodings)
        if len(encfsgui_globals.g_Encodings) == 0:
            self.volumetable.setEnabled(False)
            self.lbl_infolabel.setText("Getting filename encoding capabilities, hold on...")
            self.lbl_infolabel.update()
            encfsgui_globals.app.processEvents()
            self.update()
            encfsgui_helper.determineFileNameEncodings()
            encfsgui_helper.print_debug("Encodings: %s" % encfsgui_globals.g_Encodings)
            encfsgui_globals.appconfig.saveSettings()
            self.volumetable.setEnabled(True)
            self.SetInfoLabel()
        return

    # context menu
    def CreateVolumeMenu(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        self.volumetablemenu.clear()
        volumename = encfsgui_globals.g_CurrentlySelected 
        if volumename != "":
            if volumename in encfsgui_globals.g_Volumes:
                EncVolumeObj = encfsgui_globals.g_Volumes[volumename]
                self.volumemenuheader = QAction("Actions for volume '%s':" % volumename, self)
                self.volumetablemenu.addAction(self.volumemenuheader)
                self.volumetablemenu.addSeparator()
                if not EncVolumeObj.ismounted:
                    self.volumemountaction = QAction(QIcon("./bitmaps/icons8-unlock-24.png"),"Mount volume", self) 
                    self.volumetablemenu.addAction(self.volumemountaction)
                    self.volumemountaction.triggered.connect(self.TableMenuMountVolume)
                    self.volumeeditaction = QAction("Edit volume", self)
                    self.volumetablemenu.addAction(self.volumeeditaction)
                    self.volumeeditaction.triggered.connect(self.EditVolumeButtonClicked)
                else:
                    self.volumeunmountaction = QAction(QIcon("./bitmaps/icons8-lock-24.png"), "Unmount volume", self)
                    self.volumetablemenu.addAction(self.volumeunmountaction)
                    self.volumeunmountaction.triggered.connect(self.TableMenuUnmountVolume)
                self.volumeinfoaction = QAction("Show info", self)
                self.volumetablemenu.addAction(self.volumeinfoaction)
                self.volumeinfoaction.triggered.connect(self.ShowVolumeInfoClicked)
        return


    # system tray menu
    def CreateTrayMenu(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        self.show_action = QAction("Show", self)
        self.hide_action = QAction("Hide", self)
        self.settings_action = QAction("Settings", self)
        self.about_action = QAction("About", self)
        self.quit_action = QAction("Quit", self)
        self.refresh_action = QAction("Refresh", self)
        
        self.show_action.triggered.connect(self.ShowButtonClicked)
        self.hide_action.triggered.connect(self.HideButtonClicked)
        self.settings_action.triggered.connect(self.SetttingsButtonClicked)
        self.about_action.triggered.connect(self.AboutClicked)
        self.quit_action.triggered.connect(self.QuitButtonClicked)
        self.refresh_action.triggered.connect(self.RefreshVolumesClicked)

        self.PopulateVolumeMenu()

        self.tray_menu.addAction(self.show_action)
        self.tray_menu.addAction(self.hide_action)
        self.tray_menu.addSeparator()
        self.tray_menu.addAction(self.refresh_action)
        self.tray_menu.addSeparator()
        self.tray_menu.addAction(self.settings_action)
        self.tray_menu.addSeparator()
        self.volume_menu.setTitle("Volumes")
        self.tray_menu.addMenu(self.volume_menu)
        self.tray_menu.addSeparator()
        self.tray_menu.addAction(self.about_action)
        self.tray_menu.addSeparator()
        self.tray_menu.addAction(self.quit_action)

        if self.isVisible():
            self.show_action.setEnabled(False)
            self.hide_action.setEnabled(True)
        else:
            self.show_action.setEnabled(True)
            self.hide_action.setEnabled(False)

        self.tray_icon.setContextMenu(self.tray_menu)
        self.tray_icon.show()
        return


    def PopulateVolumeMenu(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        self.volume_menu.clear()
        buildmenu = False
        # only build menu in certain cases
        encfsgui_helper.print_debug("Main window hidden? %s" % str(encfsgui_globals.ishidden))
        encfsgui_helper.print_debug("Encrypt? %s" % encfsgui_globals.g_Settings["encrypt"].lower() )
        encfsgui_helper.print_debug("Clear Key? %s" % encfsgui_globals.g_Settings["clearkeywhenhidden"].lower())
        if not encfsgui_globals.ishidden:
            buildmenu = True
        else:
            if encfsgui_globals.g_Settings["encrypt"].lower() == "true" and encfsgui_globals.g_Settings["clearkeywhenhidden"].lower() == "true": 
                buildmenu = False
            else:
                buildmenu = True
        if buildmenu: 
            self.volume_menu.setEnabled(True)
            sorted_volumes = {k: encfsgui_globals.g_Volumes[k] for k in sorted(encfsgui_globals.g_Volumes)}
            for volumename in sorted_volumes:
                EncVolumeObj = encfsgui_globals.g_Volumes[volumename]

                addtolist = True

                if encfsgui_globals.g_Settings["hidevolumenotfound"].lower() == "true":
                    addtolist = EncVolumeObj.enc_path_exists

                if addtolist:
                    self.volume_mount = QAction(QIcon("./bitmaps/icons8-unlock-24.png"),  "Mount '%s'" % volumename, self)
                    self.volume_mount.triggered.connect(self.MenuMountVolume)
                    self.volume_menu.addAction(self.volume_mount)
                    
                    self.volume_unmount = QAction(QIcon("./bitmaps/icons8-lock-24.png"), "Unmount '%s'" % volumename, self)
                    self.volume_unmount.triggered.connect(self.MenuUnmountVolume)
                    self.volume_menu.addAction(self.volume_unmount)

                    self.volume_menu.addSeparator()

                    if EncVolumeObj.ismounted:
                        self.volume_mount.setEnabled(False)
                        self.volume_mount.setVisible(False)
                        self.volume_unmount.setEnabled(True)
                        self.volume_unmount.setVisible(True)
                    else:
                        self.volume_mount.setEnabled(True)
                        self.volume_mount.setVisible(True)
                        self.volume_unmount.setEnabled(False)
                        self.volume_unmount.setVisible(False)
        else:
            self.volume_menu.setEnabled(False)
        return

    def MenuMountVolume(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        actionname = self.sender().text()
        volumename = self.getVolumeNameFromAction(actionname)
        if volumename in encfsgui_globals.g_Volumes:
            thispassword = self.getPasswordForVolume(volumename)
            self.MountVolume(volumename, thispassword)
        self.PopulateVolumeMenu()
        return

    def TableMenuMountVolume(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        volumename = encfsgui_globals.g_CurrentlySelected
        if volumename in encfsgui_globals.g_Volumes:
            thispassword = self.getPasswordForVolume(volumename)
            self.MountVolume(volumename, thispassword)
        self.PopulateVolumeMenu()
        return

    def MenuUnmountVolume(self, action):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        actionname = self.sender().text()
        volumename = self.getVolumeNameFromAction(actionname)
        self.UnmountVolume(volumename)
        self.PopulateVolumeMenu()
        return

    def TableMenuUnmountVolume(self, action):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        volumename = encfsgui_globals.g_CurrentlySelected
        self.UnmountVolume(volumename)
        self.PopulateVolumeMenu()
        return

    def getVolumeNameFromAction(self, actionname):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        volumename = ""
        if (actionname.startswith("Mount")):
            volumename = actionname.lstrip("Mount ").lstrip("'").rstrip("'")
        elif (actionname.startswith("Unmount")):
            volumename = actionname.lstrip("Unmount ").lstrip("'").rstrip("'")
        return volumename


    def CreateVolumeButtonClicked(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        self.checkFilenameEncodings()
        createvolumewindow = CVolumeWindow()
        createvolumewindow.show()
        createvolumewindow.setRunMode(0)    # create
        createvolumewindow.setFocus()
        createvolumewindow.activateWindow()
        createvolumewindow.exec_()
        self.RefreshVolumes()
        self.PopulateVolumeMenu()
        return


    def AddVolumeButtonClicked(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        addvolumewindow = CVolumeWindow()
        addvolumewindow.show()
        addvolumewindow.setRunMode(1)    # add
        addvolumewindow.setFocus()
        addvolumewindow.activateWindow()
        addvolumewindow.exec_()
        self.RefreshVolumes()
        self.PopulateVolumeMenu()
        return       

    def EditVolumeButtonClicked(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        self.checkFilenameEncodings()
        if encfsgui_globals.g_CurrentlySelected != "":
            editvolumewindow = CVolumeWindow()
            editvolumewindow.show()
            editvolumewindow.setRunMode(2)    # edit
            editvolumewindow.origvolumename = encfsgui_globals.g_CurrentlySelected
            editvolumewindow.PopulateFields(encfsgui_globals.g_CurrentlySelected)
            editvolumewindow.setFocus()
            editvolumewindow.activateWindow()
            editvolumewindow.exec_()
            encfsgui_globals.appconfig.getVolumes()
            self.RefreshVolumes()
        return 

    def RemoveVolumeClicked(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        volumename = encfsgui_globals.g_CurrentlySelected
        if volumename != "":
            if volumename in encfsgui_globals.g_Volumes: 
                EncVolumeObj = encfsgui_globals.g_Volumes[volumename]
                msgBox = QtWidgets.QMessageBox()
                msgBox.setIcon(QtWidgets.QMessageBox.Question)
                msgBox.setWindowTitle("Are you sure?")
                msgBox.setText("Are you sure you would like to remove volume '%s' from this app?\n (mounted at '%s')?\n\nNote: this will not unmount the volume, and will not remove the actual encrypted folder.\nI will only remove the volume from the application." % (volumename, EncVolumeObj.mount_path))
                msgBox.setStandardButtons(QtWidgets.QMessageBox.No)
                msgBox.addButton(QtWidgets.QMessageBox.Yes)
                msgBox.show()
                if (msgBox.exec_() == QtWidgets.QMessageBox.Yes):
                    encfsgui_helper.RemovePasswordFromKeyChain(volumename)
                    encfsgui_globals.appconfig.delVolume(volumename)                  
                    encfsgui_globals.appconfig.getVolumes()
                    self.RefreshVolumes()
        return

    def ShowVolumeInfoClicked(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        volumename = encfsgui_globals.g_CurrentlySelected
        if volumename != "":
            if volumename in encfsgui_globals.g_Volumes:
                EncVolumeObj =  encfsgui_globals.g_Volumes[volumename]
                infotext = ""
                if EncVolumeObj.enctype == "encfs":
                    if os.path.exists(encfsgui_globals.g_Settings["encfspath"]):
                        cmd = "%sctl info '%s'" % (encfsgui_globals.g_Settings["encfspath"], EncVolumeObj.enc_path)
                        cmdoutput = encfsgui_helper.execOSCmd(cmd)
                        infotext = "EncFS volume info for '%s'\n" % volumename
                        infotext += "Encrypted folder '%s'\n\n" % EncVolumeObj.enc_path
                        for l in cmdoutput:
                            infotext = infotext + l + "\n"

                if EncVolumeObj.enctype == "gocryptfs":
                    if os.path.exists(encfsgui_globals.g_Settings["gocryptfspath"]):
                        cmd = "%s -info '%s'" % (encfsgui_globals.g_Settings["gocryptfspath"], EncVolumeObj.enc_path)
                        cmdoutput = encfsgui_helper.execOSCmd(cmd)
                        infotext = "GoCryptFS volume info for '%s'\n" % volumename
                        infotext += "Encrypted folder '%s'\n\n" % EncVolumeObj.enc_path
                        for l in cmdoutput:
                            infotext = infotext + l + "\n"
                if not infotext == "":
                    msgBox = QtWidgets.QMessageBox()
                    msgBox.setIcon(QtWidgets.QMessageBox.Information)
                    msgBox.setWindowTitle("Encrypted Volume info (%s)" % EncVolumeObj.enctype)
                    msgBox.setText(infotext)
                    msgBox.setStandardButtons(QtWidgets.QMessageBox.Ok)
                    msgBox.show()
                    msgBox.exec_()
        return

    def RefreshVolumesClicked(self): 
        self.RefreshVolumes()
        return

    def SetttingsButtonClicked(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        settingswindow = CSettingsWindow()
        settingswindow.loadSettings()
        settingswindow.show()
        settingswindow.setFocus()
        settingswindow.activateWindow()
        settingswindow.exec_()
        # when dialog closes, refresh settings (in case user made a change)
        self.RefreshSettings()
        # don't refresh gui if gui is hidden, otherwise app might ask for master key
        if not encfsgui_globals.ishidden:
            self.RefreshVolumes()
        self.PopulateVolumeMenu()
        return

    def MountVolumeClicked(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        # do we need to ask for password?
        if encfsgui_globals.g_CurrentlySelected != "":
            if encfsgui_globals.g_CurrentlySelected in encfsgui_globals.g_Volumes:
                thispassword = self.getPasswordForVolume(encfsgui_globals.g_CurrentlySelected)
                self.MountVolume(encfsgui_globals.g_CurrentlySelected, thispassword)
        return

    def getPasswordForVolume(self, volumename):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        thispassword = ""
        EncVolumeObj = encfsgui_globals.g_Volumes[volumename]
        if str(EncVolumeObj.passwordsaved) == "0":
            frmpassword = CMountPasswordWindow()
            frmpassword.setEncPath(EncVolumeObj.enc_path)
            frmpassword.setMountPath(EncVolumeObj.mount_path)
            frmpassword.setWindowTitle("Please enter password for volume '%s'" % volumename)
            frmpassword.show()
            frmpassword.setFocus()
            frmpassword.activateWindow()
            frmpassword.exec_()
            thispassword = frmpassword.getPassword()
        else:
            thispassword = str(encfsgui_helper.getKeyChainPassword(volumename))
        return thispassword

    def UnmountVolumeClicked(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        if encfsgui_globals.g_CurrentlySelected != "":
            volumename = encfsgui_globals.g_CurrentlySelected
            self.UnmountVolume(volumename) 
        return

    def UnmountAllClicked(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        continueunmount = True
        if  encfsgui_globals.g_Settings["confirmforceunmountall"].lower() == "true":
            forcedmsgBox = QtWidgets.QMessageBox()
            forcedmsgBox.setIcon(QMessageBox.Question)
            forcedmsgBox.setWindowTitle("Are you sure?")
            forcedmsgBox.setText("Are you sure you would like to forcibly unmount all volumes now?")
            forcedmsgBox.setStandardButtons(QtWidgets.QMessageBox.Yes)
            forcedmsgBox.addButton(QtWidgets.QMessageBox.No)
            forcedmsgBox.show()
            if (forcedmsgBox.exec_() == QtWidgets.QMessageBox.No):
                continueunmount = False
        if continueunmount:
            for volumename in encfsgui_globals.g_Volumes:
                self.UnmountVolume(volumename, True)
        self.RefreshVolumes()
        return

    def UnmountVolume(self, volumename, forced=False):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        # do we need to ask for confirmation?
        askforconfirmation = True
        dounmount = False
        if "noconfirmationunmount" in encfsgui_globals.g_Settings:
            if encfsgui_globals.g_Settings["noconfirmationunmount"].lower() == "true":
                askforconfirmation = False

        if volumename in encfsgui_globals.g_Volumes:
            EncVolumeObj = encfsgui_globals.g_Volumes[volumename]
            if EncVolumeObj.ismounted:
                dounmount = True
                if askforconfirmation and not forced:
                    msgBox = QtWidgets.QMessageBox()
                    msgBox.setIcon(QMessageBox.Question)
                    msgBox.setWindowTitle("Are you sure?")
                    msgBox.setText("Unmount volume '%s' \n '%s'?\n\n(Make sure all files on this volume are closed first!)" % (volumename, EncVolumeObj.mount_path))
                    msgBox.setStandardButtons(QtWidgets.QMessageBox.Yes)
                    msgBox.addButton(QtWidgets.QMessageBox.No)
                    msgBox.show()
                    if (msgBox.exec_() == QtWidgets.QMessageBox.No):
                        dounmount = False

            if dounmount:
                cmd = "'%s' '%s'" % (encfsgui_globals.g_Settings["umountpath"], EncVolumeObj.mount_path)
                if EncVolumeObj.sudo == "1":
                    cmd = "sudo '%s' '%s'" % (encfsgui_globals.g_Settings["umountpath"], EncVolumeObj.mount_path)
                encfsgui_helper.execOSCmd(cmd)
                # did unmount work?
                self.RefreshVolumes()
                EncVolumeObj = encfsgui_globals.g_Volumes[volumename]
                if EncVolumeObj.ismounted:
                    QtWidgets.QMessageBox.critical(None,"Error unmounting volume","Unable to unmount volume '%s'\nMake sure all files are closed and try again." % volumename)

        # update context menu's
        self.PopulateVolumeMenu()

        return


    def BrowseVolumeClicked(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        if encfsgui_globals.g_CurrentlySelected != "":
            if encfsgui_globals.g_CurrentlySelected in encfsgui_globals.g_Volumes:
                EncVolumeObj = encfsgui_globals.g_Volumes[encfsgui_globals.g_CurrentlySelected]
                encfsgui_helper.openFolder(EncVolumeObj.mount_path)
        return

    def MountVolume(self, volumename, password):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        if volumename in encfsgui_globals.g_Volumes:
            EncVolumeObj = encfsgui_globals.g_Volumes[volumename]
            if (password != ""):
                if not encfsgui_helper.ifExists(EncVolumeObj.enctype):
                    QtWidgets.QMessageBox.critical(None,"Error mounting volume","Unable to mount volume '%s', '%s' binary not found\n" % ( volumename, EncVolumeObj.enctype))
                else:
                    usesudo = ""
                    if EncVolumeObj.sudo == "1":
                        usesudo = "sudo"

                    # if volume is encfs:
                    if EncVolumeObj.enctype == "encfs":
                        extra_osxfuse_opts = ""
                        #mountcmd = "%s '%s' '%s' %s" % (encfsgui_globals.g_Settings["encfspath"], EncVolumeObj.enc_path, EncVolumeObj.mount_path, EncVolumeObj.encfsmountoptions)
                        if (str(EncVolumeObj.allowother) == "1"):
                            extra_osxfuse_opts += "-o allow_other "
                        if (str(EncVolumeObj.mountaslocal) == "1"):
                            extra_osxfuse_opts += "-o local "
                        # first, create mount point if necessary
                        createfoldercmd = "mkdir -p '%s'" % EncVolumeObj.mount_path
                        encfsgui_helper.execOSCmd(createfoldercmd)

                        encfsbin = encfsgui_globals.g_Settings["encfspath"]
                        encvol = EncVolumeObj.enc_path
                        mountvol = EncVolumeObj.mount_path
                        encfsmountoptions = ""
                        if not EncVolumeObj.encfsmountoptions == "":
                            encfsmountoptions = "'%s'" % EncVolumeObj.encfsmountoptions

                        # do the actual mount
                        mountcmd = "sh -c \"echo '%s' | %s '%s' -v -S %s %s -o volname='%s' '%s' '%s' \"" % (str(password), usesudo, encfsbin, extra_osxfuse_opts, encfsmountoptions, volumename, encvol, mountvol)

                        encfsgui_helper.execOSCmd(mountcmd)

                    # if volume is gocryptfs:
                    if EncVolumeObj.enctype == "gocryptfs":
                        extra_osxfuse_opts = ""
                        extra_gocryptfs_opts = ""
                        if (str(EncVolumeObj.allowother) == "1"):
                            extra_gocryptfs_opts += "-allow_other "
                        if (str(EncVolumeObj.mountaslocal) == "1"):
                            extra_osxfuse_opts += "-ko local "
                        # first, create mount point if necessary
                        createfoldercmd = "mkdir -p '%s'" % EncVolumeObj.mount_path
                        encfsgui_helper.execOSCmd(createfoldercmd)

                        gocryptfsbin = encfsgui_globals.g_Settings["gocryptfspath"]
                        encvol = EncVolumeObj.enc_path
                        mountvol = EncVolumeObj.mount_path
                        if not EncVolumeObj.encfsmountoptions == "":
                            extra_gocryptfs_opts += "'%s'" % EncVolumeObj.encfsmountoptions

                        # do the actual mount
                        #mountcmd = "sh -c \"echo '%s' | %s -v -S %s %s -o volname='%s' '%s' '%s' \"" % (str(password), gocryptfsbin, extra_osxfuse_opts, gocryptfsmountoptions, volumename, encvol, mountvol)
                        mountcmd = "sh -c \"echo '%s' | %s '%s' -ko volname='%s' -ko fsname='%s' %s %s '%s' '%s'\"" % (str(password), usesudo, gocryptfsbin, volumename, volumename, extra_osxfuse_opts, extra_gocryptfs_opts, encvol, mountvol)

                        encfsgui_helper.execOSCmd(mountcmd)

                    self.RefreshVolumes()
                    EncVolumeObj = encfsgui_globals.g_Volumes[volumename]
                    if not EncVolumeObj.ismounted:
                        QtWidgets.QMessageBox.critical(None,"Error mounting volume","Unable to mount volume '%s'\n\n%s" % ( volumename, EncVolumeObj.errormessage ))
            else:
                encfsgui_helper.print_debug("Did not attempt to mount, empty password given")

            # update context menu's
            self.PopulateVolumeMenu()
        return


    def TableEntrySelected(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        # update the currently selected volume
        encfsgui_globals.g_CurrentlySelected = ""
        selectedindex = 0
        for currentQTableWidgetItem in self.volumetable.selectedItems():
            if selectedindex == 1:
                encfsgui_globals.g_CurrentlySelected = currentQTableWidgetItem.text()
                encfsgui_helper.print_debug("Selected entry %s" % encfsgui_globals.g_CurrentlySelected)
            selectedindex += 1
        # enable/disable buttons accordingly
        self.EnableDisableButtons()
        return


    def RefreshVolumes(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        # don't reload if main window is hidden, prevent masterkey to be required
        curframe = inspect.currentframe()
        calframe = inspect.getouterframes(curframe, 2)
        encfsgui_helper.print_debug("%s() Called from: %s()" % (inspect.stack()[0][3],calframe[1][3]))          
    
        # get volumes from config file
        encfsgui_globals.appconfig.getVolumes()
        # show volumes in the table
        self.volumetable.clearContents()
        self.volumetable.setColumnCount(5)
        
        #self.volumetable.setRowCount(len(encfsgui_globals.g_Volumes))
        self.volumetable.setRowCount(0)

        columnheaders = ['Mounted?', 'Volume Name', 'Encrypted folder', 'Mount at', 'Automount?']
        self.volumetable.setHorizontalHeaderLabels(columnheaders)

        self.volumetable.setColumnWidth(0,75)
        self.volumetable.setColumnWidth(1,125)
        self.volumetable.setColumnWidth(2,365)
        self.volumetable.setColumnWidth(3,325)
        self.volumetable.setColumnWidth(4,95)

        # sort 
        sorted_volumes = {k: encfsgui_globals.g_Volumes[k] for k in sorted(encfsgui_globals.g_Volumes)}

        volumeindex = 0
        volumesfoundsofar = 0
        for volumekey in sorted_volumes:
            EncVolumeObj = encfsgui_globals.g_Volumes[volumekey]
            addtolist = True

            if encfsgui_globals.g_Settings["hidevolumenotfound"].lower() == "true":
                addtolist = EncVolumeObj.enc_path_exists

            if addtolist:
                volumesfoundsofar += 1
                self.volumetable.setRowCount(volumesfoundsofar)

                mountedtext = "NO"
                if EncVolumeObj.ismounted:
                    mountedtext = "YES"
                
                automounttext = "NO"
                if str(EncVolumeObj.automount) == "1":
                    automounttext = "YES"

                boldfont = QFont()
                boldfont.setBold(True)

                regularfont = QFont()
                regularfont.setBold(False)
                mountstate = QTableWidgetItem(mountedtext)
                
                if EncVolumeObj.ismounted:    
                    mountstate.setFont(boldfont)
                    mountstate.setForeground(QColor(255,0,0))
                else:
                    mountstate.setFont(regularfont)
                    mountstate.setForeground(QColor(0,255,0))

                self.volumetable.setItem(volumeindex,0, mountstate)
                self.volumetable.setItem(volumeindex,1, QTableWidgetItem(volumekey))
                self.volumetable.setItem(volumeindex,2, QTableWidgetItem(EncVolumeObj.enc_path))
                self.volumetable.setItem(volumeindex,3, QTableWidgetItem(EncVolumeObj.mount_path))
                self.volumetable.setItem(volumeindex,4, QTableWidgetItem(automounttext))

                self.volumetable.setRowHeight(volumeindex,12)

                volumeindex += 1
                
        self.SetInfoLabel()
        return

    def AutoMount(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        # process automounts
        for volumename in encfsgui_globals.g_Volumes:
            EncVolumeObj = encfsgui_globals.g_Volumes[volumename]
            if str(EncVolumeObj.automount) == "1":
                if not EncVolumeObj.ismounted:
                    thispassword = self.getPasswordForVolume(volumename)
                    self.MountVolume(volumename, thispassword)
        return

    def AutoUnMount(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        if str(encfsgui_globals.g_Settings["autounmount"]) == "true":
            # unmount the volumes that don't have preventautounmount set
            for volumename in encfsgui_globals.g_Volumes:
                EncVolumeObj = encfsgui_globals.g_Volumes[volumename]
                if str(EncVolumeObj.preventautounmount) == "0":
                    self.UnmountVolume(volumename)
        return

    def RefreshSettings(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        encfsgui_globals.appconfig.getSettings()
        #if not encfsgui_globals.ishidden:
        #    self.SetInfoLabel()
        return

    def SetInfoLabel(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        encfspath = encfsgui_globals.g_Settings["encfspath"]
        gocryptfspath = encfsgui_globals.g_Settings["gocryptfspath"]
        encfsinfo = "encfs not found"

        if os.path.exists(encfspath):
            encfsinfo = "encfs v%s" % (getEncFSVersion())
        gocryptfsinfo = "gocryptfs not found"

        if os.path.exists(gocryptfspath):
            gocryptfsinfo = "gocryptfs %s" % (getGoCryptFSVersion())

        self.lbl_infolabel.setText(" %s  | %s  |  Nr of volumes: %d  |  %s" % (encfsinfo, gocryptfsinfo, self.volumetable.rowCount(), encfsgui_globals.volumesfile ))
        self.lbl_infolabel.update()
        encfsgui_globals.app.processEvents()
        return

    def EnableDisableButtons(self):
        encfsgui_helper.print_debug("Start %s" % inspect.stack()[0][3])
        # did we select an entry in the table?
        selectedenable = False
        if encfsgui_globals.g_CurrentlySelected != "":
            selectedenable = True
            mounted = False
            if encfsgui_globals.g_CurrentlySelected in encfsgui_globals.g_Volumes:
                mounted = encfsgui_globals.g_Volumes[encfsgui_globals.g_CurrentlySelected].ismounted
            if mounted:
                self.mountvolumebutton.setEnabled(False)
                self.unmountvolumebutton.setEnabled(True)
                self.browsevolumebutton.setEnabled(True)
                self.editvolumebutton.setEnabled(False)
            else:
                self.mountvolumebutton.setEnabled(True)
                self.unmountvolumebutton.setEnabled(False)
                self.browsevolumebutton.setEnabled(False)
                self.editvolumebutton.setEnabled(True)
        else:
            self.mountvolumebutton.setEnabled(False)
            self.unmountvolumebutton.setEnabled(False)
            self.browsevolumebutton.setEnabled(False)
            self.editvolumebutton.setEnabled(False)

        self.infovolumebutton.setEnabled(selectedenable)
        self.removevolumebutton.setEnabled(selectedenable)

        return
 def showStateContextMenu(self, stateItem, qEvent):
     cMenu = QMenu()
     cMenu.addAction(self.renameStateAction)
     cMenu.addAction(self.stateCodeAction)
     cMenu.addAction(self.makeInitialAction)
     cMenu.addAction(self.copyStateAction)
     cMenu.addAction(self.removeStateAction)
     cMenu.addAction(self.importStateAction)
     self.selectedState = stateItem
     self.contextPosition = qEvent.screenPos()
     action = cMenu.exec_(qEvent.screenPos())
Beispiel #54
0
    def _on_contextmenu(self, pos):
        context_menu = QMenu(self)
        index = self._bookmarks_list.indexAt(pos).row()
        if index != -1:
            context_menu.addAction(
                'Copy address', lambda: utils.copy_hex_to_clipboard(
                    self._bookmarks_model.item(index, 0).text()))
            context_menu.addAction(
                'Jump to address', lambda: self._app_window.jump_to_address(
                    self._bookmarks_model.item(index, 0).text()))

            # todo: add breakpoint address menu

            context_menu.addSeparator()
            context_menu.addAction('Edit',
                                   lambda: self._create_bookmark(index=index))
            context_menu.addAction('Delete',
                                   lambda: self._on_delete_bookmark(index))
            context_menu.addSeparator()
            if self._bookmarks_list.search_enabled:
                context_menu.addSeparator()
                context_menu.addAction('Search',
                                       self._bookmarks_list._on_cm_search)
                context_menu.addSeparator()
        context_menu.addAction('New', self._create_bookmark)
        global_pt = self._bookmarks_list.mapToGlobal(pos)
        context_menu.exec(global_pt)
 def showSceneContextMenu(self, qEvent):
     cMenu = QMenu()
     cMenu.addAction(self.pasteStateAction)
     self.currentScenePos = qEvent.scenePos()
     action = cMenu.exec_(qEvent.screenPos())
Beispiel #56
0
    def _layout_modify_structure(self, parent):
        layout = QVBoxLayout()
        layout.setContentsMargins(0,0,0,0)
        layout.setSpacing(0)
        parent.setLayout(layout)

        layout.addWidget(QLabel("Change selected atom to..."), alignment=Qt.AlignHCenter | Qt.AlignBottom)
        frame = QFrame()
        layout.addWidget(frame, alignment=Qt.AlignHCenter | Qt.AlignTop)
        frame.setLineWidth(1)
        frame.setFrameStyle(QFrame.Panel | QFrame.Plain)
        frame_layout = QVBoxLayout()
        frame_layout.setContentsMargins(0,0,0,0)
        frame_layout.setSpacing(0)
        frame.setLayout(frame_layout)
        params_layout = QGridLayout()
        params_layout.setHorizontalSpacing(10)
        params_layout.setVerticalSpacing(0)
        frame_layout.addLayout(params_layout)
        for col, title in enumerate(["Element", "Bonds", "Geometry"]):
            params_layout.addWidget(QLabel(title), 0, col, alignment=Qt.AlignHCenter | Qt.AlignBottom)
        self.ms_elements_button = ebut = QPushButton()
        from chimerax.atomic.widgets import make_elements_menu
        elements_menu = make_elements_menu(parent)
        elements_menu.triggered.connect(lambda act, but=ebut: but.setText(act.text()))
        ebut.setMenu(elements_menu)
        ebut.setText("C")
        params_layout.addWidget(ebut, 1, 0)

        self.ms_bonds_button = bbut = QPushButton()
        bonds_menu = QMenu(parent)
        for nb in range(5):
            bonds_menu.addAction(str(nb))
        bonds_menu.triggered.connect(lambda act, but=bbut: but.setText(act.text()))
        bbut.setMenu(bonds_menu)
        bbut.setText("4")
        params_layout.addWidget(bbut, 1, 1)

        self.ms_geom_button = gbut = QPushButton()
        geom_menu = QMenu(parent)
        geom_menu.triggered.connect(lambda act, but=gbut: but.setText(act.text()))
        bonds_menu.triggered.connect(lambda act: self._ms_geom_menu_update())
        gbut.setMenu(geom_menu)
        params_layout.addWidget(gbut, 1, 2)
        self._ms_geom_menu_update()

        atom_name_area = QWidget()
        frame_layout.addWidget(atom_name_area, alignment=Qt.AlignCenter)
        atom_name_layout = QGridLayout()
        atom_name_layout.setContentsMargins(0,0,0,0)
        atom_name_layout.setSpacing(0)
        atom_name_area.setLayout(atom_name_layout)
        self.ms_retain_atom_name = rbut = QRadioButton("Retain current atom name")
        rbut.setChecked(True)
        atom_name_layout.setColumnStretch(1, 1)
        atom_name_layout.addWidget(rbut, 0, 0, 1, 2, alignment=Qt.AlignLeft)
        self.ms_change_atom_name = QRadioButton("Set atom name to:")
        atom_name_layout.addWidget(self.ms_change_atom_name, 1, 0)
        self.ms_atom_name = name_edit = QLineEdit()
        name_edit.setFixedWidth(50)
        name_edit.setText(ebut.text())
        elements_menu.triggered.connect(lambda act: self._ms_update_atom_name())
        atom_name_layout.addWidget(name_edit, 1, 1, alignment=Qt.AlignLeft)

        apply_but = QPushButton("Apply")
        apply_but.clicked.connect(lambda checked: self._ms_apply_cb())
        layout.addWidget(apply_but, alignment=Qt.AlignCenter)

        checkbox_area = QWidget()
        layout.addWidget(checkbox_area, alignment=Qt.AlignCenter)
        checkbox_layout = QVBoxLayout()
        checkbox_area.setLayout(checkbox_layout)
        self.ms_connect_back = connect = QCheckBox("Connect to pre-existing atoms if appropriate")
        connect.setChecked(True)
        checkbox_layout.addWidget(connect, alignment=Qt.AlignLeft)
        self.ms_focus = focus = QCheckBox("Focus view on modified residue")
        focus.setChecked(False)
        checkbox_layout.addWidget(focus, alignment=Qt.AlignLeft)
        self.ms_element_color = color = QCheckBox("Color new atoms by element")
        color.setChecked(True)
        checkbox_layout.addWidget(color, alignment=Qt.AlignLeft)

        res_group = QGroupBox("Residue Name")
        layout.addWidget(res_group, alignment=Qt.AlignCenter)
        group_layout = QGridLayout()
        group_layout.setContentsMargins(0,0,0,0)
        group_layout.setSpacing(0)
        res_group.setLayout(group_layout)
        self.ms_res_unchanged = QRadioButton("Leave unchanged")
        group_layout.addWidget(self.ms_res_unchanged, 0, 0, 1, 3, alignment=Qt.AlignLeft)
        self.ms_res_mod = QRadioButton("Change modified residue's name to")
        group_layout.addWidget(self.ms_res_mod, 1, 0, 1, 1, alignment=Qt.AlignLeft)
        self.ms_mod_edit = QLineEdit()
        self.ms_mod_edit.setFixedWidth(50)
        self.ms_mod_edit.setText("UNL")
        group_layout.addWidget(self.ms_mod_edit, 1, 1, 1, 2, alignment=Qt.AlignLeft)
        self.ms_res_new = QRadioButton("Put just changed atoms in new residue named")
        group_layout.addWidget(self.ms_res_new, 2, 0, 1, 2, alignment=Qt.AlignLeft)
        self.ms_res_new_name = QLineEdit()
        self.ms_res_new_name.setFixedWidth(50)
        self.ms_res_new_name.setText("UNL")
        group_layout.addWidget(self.ms_res_new_name, 2, 2, 1, 1)

        self.ms_res_mod.setChecked(True)

        from chimerax.core.selection import SELECTION_CHANGED
        self.handlers.append(self.session.triggers.add_handler(SELECTION_CHANGED, self._ms_sel_changed))
        self._ms_sel_changed()

        sep = QFrame()
        sep.setFrameStyle(QFrame.HLine)
        layout.addWidget(sep, stretch=1)

        delete_area = QWidget()
        layout.addWidget(delete_area, alignment=Qt.AlignCenter)
        delete_layout = QHBoxLayout()
        delete_area.setLayout(delete_layout)
        del_but = QPushButton("Delete")
        del_but.clicked.connect(self._ms_del_cb)
        delete_layout.addWidget(del_but, alignment=Qt.AlignRight)
        delete_layout.addWidget(QLabel("selected atoms/bonds"), alignment=Qt.AlignLeft)
Beispiel #57
0
    def _onTvFilesCustomContextMenuRequested(self, pos):
        """Connected automatically by uic
        """
        menu = QMenu()

        menu.addAction(core.actionManager().action("mFile/mClose/aCurrent"))
        menu.addAction(core.actionManager().action("mFile/mSave/aCurrent"))
        menu.addAction(core.actionManager().action("mFile/mReload/aCurrent"))
        menu.addSeparator()
        menu.addAction(
            core.actionManager().action("mFile/mFileSystem/aRename"))
        toggleExecutableAction = core.actionManager().action(
            "mFile/mFileSystem/aToggleExecutable")
        if toggleExecutableAction:  # not available on Windows
            menu.addAction(toggleExecutableAction)
        core.actionManager().action("mFile/mFileSystem").menu(
        ).aboutToShow.emit()  # to update aToggleExecutable

        menu.exec_(self.tvFiles.mapToGlobal(pos))
Beispiel #58
0
class MainWindow(QMainWindow):
    """
    主窗口界面
    """

    def __init__(self, *args, **kwargs):
        super(MainWindow, self).__init__(*args, **kwargs)

        # 初始化
        self.init()
        # ui设计
        self.setup_ui()
        # 创建右键菜单
        self.create_context_menu()
        # 主框体设计
        self.set_main_form()
        # 加载qss样式
        self.load_qss()

    def init(self):
        self.setGeometry(Const.WIN_X, Const.WIN_Y, Const.WIN_WIDTH, Const.WIN_HEIGHT)
        self.setObjectName('mainWindow')
        self.setWindowIcon(QIcon("./image/Logo/logo.png"))
        self.setWindowTitle('IFR智能公式识别系统')

        # 加载图片缩放公共类
        self.imageScale = ImageScale()

    def setup_ui(self):
        """
        创建状态栏、菜单栏、工具栏
        """

        # 状态栏
        self.statusBar = QStatusBar()
        self.setStatusBar(self.statusBar)
        self.statusBar.showMessage('准备就绪', 5000)
        # self.statusBar().setStyleSheet('background-color:lightGray;')

        # 菜单栏
        self.menubar = QMenuBar()
        self.setMenuBar(self.menubar)
        # self.menuBar().setStyleSheet('background-color:lightGray;')

        # 文件
        self.fileMenu = self.menubar.addMenu('&文件(F)')

        # 调用自定义action
        self.openPimax = Action.action_b_2(self, 'openPimax', '&打开图片文件', 'Ctrl+P', '打开图片文件')
        self.openPimax.setIcon(QIcon('./image/openQpixmap.jpg'))
        self.openText = Action.action_b_2(self, 'openText', '&打开文本文件', 'Ctrl+T', '打开文本文件')
        self.openText.setIcon(QIcon('./image/openText.ico'))
        self.openFile = Action.action_b_3(self, 'openFile', '打开文件', '打开文件', self.fileMenu)
        self.openFile.addAction(self.openPimax)
        self.openFile.addAction(self.openText)

        self.openPimax.triggered.connect(lambda: self.get_image())
        self.openText.triggered.connect(lambda: self.get_text())
        self.openRecentFile = Action.action_a_2(self, 'openRecentFile', '&最近打开的文件', 'Ctrl+O', '最近打开的文件', self.fileMenu)
        # self.openRecentFile.triggered.connect(self.)
        self.save = Action.action_a_2(self, 'save', '&保存分析结果', 'Ctrl+S', '保存数据分析结果', self.fileMenu)
        # self.save.triggered.connect(self.)
        self.saveAs = Action.action_a_2(self, 'saveAs', '&另保存分析结果', 'Ctrl+Shift+S', '另保存数据分析结果', self.fileMenu)
        # self.saveAs.triggered.connect(self.)
        self.printf = Action.action_a_2(self, 'printef', '&打印分析结果', 'Ctrl+P', '打印数据分析结果', self.fileMenu)
        # self.printf.triggered.connect(self.)
        self.exitAction = Action.action_a_1(self, 'exitAction', './image/mainWindowIcon/toolBarIcon/exit.png', '&退出',
                                            'Ctrl+Q', '退出应用程序',
                                            self.fileMenu)
        self.exitAction.triggered.connect(self.close)

        # 编辑
        self.exitMenu = self.menubar.addMenu('&编辑(E)')
        #
        # ####################查找与替换####################开始
        self.search = Action.action_b_2(self, 'search', '&快速查找', 'Ctrl+F', '快速查找')
        self.replace = Action.action_b_2(self, 'replace', '&快速替换', 'Ctrl+H', '快速替换')

        # 新增二级菜单
        self.searchAndReplaceMenu = Action.action_b_3(self, 'searchAndReplaceMenu', '查找与替换', '查找与替换', self.exitMenu)
        self.searchAndReplaceMenu.addAction(self.search)
        self.searchAndReplaceMenu.addAction(self.replace)

        # self.search.triggered.connect(self.)
        # self.replace.triggered.connect(self.)

        # ####################查找与替换####################结束

        self.cut = Action.action_a_2(self, 'cut', '&剪切', 'Ctrl+X', '剪切', self.exitMenu)
        # self.cut.triggered.connect(self.)
        self.copy = Action.action_a_2(self, 'copy', '&复制', 'Ctrl+C', '复制', self.exitMenu)
        # self.copy.triggered.connect(self.)
        self.paste = Action.action_a_2(self, 'paste', '&粘贴', 'Ctrl+V', '粘贴', self.exitMenu)
        # self.paste.triggered.connect(self.)
        self.delete = Action.action_a_2(self, 'delect', '&删除', 'Del', '删除', self.exitMenu)
        # self.delect.triggered.connect(self.)
        self.selectAll = Action.action_a_2(self, 'selectAll', '&全选', 'Ctrl+Alt', '全选', self.exitMenu)
        # self.selectAll.triggered.connect(self.)

        # 视图
        self.viewMenu = self.menubar.addMenu('&视图(V)')

        self.notice = Action.action_a_2(self, 'notice', '&通知', 'Ctrl+Alt+X', '信息通知提醒', self.viewMenu)
        # self.notice.triggered.connect(self.)

        # ####################窗口管理####################开始
        self.window = Action.action_b_3(self, 'window', '&窗口', '展示一些基本窗口', self.viewMenu)

        # ####################窗口管理####################结束
        #
        #
        #
        # ####################工具栏####################开始
        self.tool = Action.action_b_3(self, 'tool', '&工具栏', '基本工具', self.viewMenu)

        self.calculator = Action.action_a_1(self, 'calculator', './image/calculator.jpg', '&计算器',
                                            'C', '计算器', self.viewMenu)
        self.calculator.triggered.connect(lambda: self.calculator_win())

        # ####################工具####################结束
        self.fullScreen = Action.action_a_2(self, 'fullScreen', '&全屏幕', 'Shift+Alt+Enter', '全屏', self.viewMenu)
        # self.fullScreen.triggered.connect(self.)
        self.propertyWindow = Action.action_a_2(self, 'propertyWindow', '&属性窗口', 'F4', '属性窗口', self.viewMenu)
        # self.propertyWindow.triggered.connect(self.)
        #

        # 分析
        self.navigateMenu = self.menubar.addMenu('&分析(N)')
        #

        # 工具
        self.toolMenu = self.menubar.addMenu('&工具(T)')
        #

        # 扩展
        self.extendMenu = self.menubar.addMenu('&扩展(X)')
        #

        # 窗口
        self.windowMenu = self.menubar.addMenu('&窗口(W)')
        #

        # 帮助
        self.helpMenu = self.menubar.addMenu('&帮助(H)')

        self.help = Action.action_a_2(self, 'help ', '&查看帮助', 'Ctrl+F1', '查看帮助', self.helpMenu)
        # self.help.triggered.connect(self.)
        # ####################菜单####################结束

        ################################################################################################################

        # ####################工具栏####################开始
        # 工具

        self.pixmapToolbar = self.addToolBar('打开图形文件')
        self.textToolbar = self.addToolBar('打开文本文件')
        self.pixmapToolbar.addAction(self.openPimax)
        self.textToolbar.addAction(self.openText)

        self.exitToolbar = self.addToolBar('退出')
        self.exitToolbar.addAction(self.exitAction)

        self.calculatorTooolbar = self.addToolBar('计算器')
        self.calculatorTooolbar.addAction(self.calculator)

        # ####################工具栏####################结束

        #  槽函数线程

    # 创建右键菜单
    def create_context_menu(self):
        """
        创建右键菜单
        :return:
        """
        self.setContextMenuPolicy(Qt.CustomContextMenu)
        self.customContextMenuRequested.connect(self.show_context_menu)

        # 创建QMenu
        self.contextMenu = QMenu(self)

        # ####################工具栏管理####################开始
        self.toolBarManagementMenu = Action.action_b_4(self, 'toolBarManagementMenu', '&工具栏管理', self.contextMenu)
        # 未完成
        # ####################工具栏管理####################结束

        self.minAtion = Action.action_a_1(self, 'minAction', './image/min.png', '&最小化', 'Ctrl+M', '最小化窗口',
                                          self.contextMenu)

        self.contextMenu.addSeparator()  # 添加分隔线

        self.cutAction = Action.action_a_2(self, 'cutAction', '&剪切', 'Ctrl+X', '剪切', self.contextMenu)
        self.copyAction = Action.action_a_2(self, 'copyAction', '&复制', 'Ctrl+C', '复制', self.contextMenu)
        self.pasteAction = Action.action_a_2(self, 'pasteAction', '&粘贴', 'Ctrl+V', '粘贴', self.contextMenu)
        self.deleteAction = Action.action_a_2(self, 'delectAction', '&删除', 'Del', '删除', self.contextMenu)
        self.selectAllAction = Action.action_a_2(self, 'selectAllAction', '&全选', 'Ctrl+Alt', '全选', self.contextMenu)

        self.contextMenu.addSeparator()  # 添加分隔线

        self.closeAction = Action.action_a_1(self, 'closeAction', './image/Exit.png', '&退出', 'Ctrl+W', '退出',
                                             self.contextMenu)

        self.minAtion.triggered.connect(self.show_mininized_window)

        self.closeAction.triggered.connect(self.quit_window)
        # self.selectAllAction.triggered.connect(self.)
        # self.cutAction.triggered.connect(self.)
        # self.copyAction.triggered.connect(self.)
        # self.pasteAction.triggered.connect(self.)
        # self.delectAction.triggered.connect(self.)

    # ****************************** 业务逻辑 *********************************
    def load_qss(self):
        """
         加载Qss样式表
        :return:
        """
        style_file = './Window/mainWindow/Qss/mainWindow.qss'
        qss_style = CommonhelperQss.read_qss(style_file)
        self.setStyleSheet(qss_style)

    def set_action_connect(self):
        """
        菜单栏、工具栏槽函数连接
        :return:
        """
        pass

    def calculator_win(self):
        """
        加载计算器窗口
        :return:
        """
        self.calculator_Win = Calculatormainwindow()
        self.calculator_Win.show()

    def set_main_form(self):
        """
        窗体布局以及主框体设计
        :return:
        """
        # 主框体
        self.mainSpiltter = QSplitter(Qt.Vertical)
        self.mainSpiltter.setObjectName('mainSpiltter')

        self.mainSpiltterLayout = QVBoxLayout()

        # 设置主窗口中心窗体
        self.setCentralWidget(self.mainSpiltter)

        # *******工作区间*******
        self.workWidget = QSplitter()
        self.workWidget.setObjectName('workWidget')
        self.mainSpiltter.addWidget(self.workWidget)

        self.workWidgetLayout = QHBoxLayout()
        self.workWidget.setLayout(self.workWidgetLayout)

        self.leftWidget = QFrame()
        self.leftWidget.setObjectName('leftWidget')
        self.leftWidget.setFrameShape(QFrame.StyledPanel)
        self.leftWidget.setMaximumWidth(230)

        self.leftWidgetLayout = QVBoxLayout()
        self.leftWidgetLayout.setContentsMargins(0, 0, 0, 0)
        self.leftWidget.setLayout(self.leftWidgetLayout)

        # self.hideBtn = QLabel()
        # self.hideBtn.setObjectName('hideBtn')
        # self.hideBtn.setPixmap(QPixmap('./image/mainWindowIcon/showAndHideIcon/hide0.ico'))
        #
        # self.showBtn = QLabel()
        # self.showBtn.setObjectName('showBtn')
        # self.showBtn.setPixmap(QPixmap('./image/mainWindowIcon/showAndHideIcon/show0.ico'))

        # 存放按钮
        self.widget = QWidget()
        self.widget.setObjectName('widget')
        self.leftWidgetLayout.addWidget(self.widget)

        pixmap = self.imageScale.pixmap_scale('./image/Logo/logo0.png', 204, 80)

        self.logoIamgeLabel = QLabel(self.widget)
        self.logoIamgeLabel.setObjectName('logoImageLabel')
        self.logoIamgeLabel.setPixmap(pixmap)

        self.widgetLayout = QGridLayout()
        self.widget.setLayout(self.widgetLayout)

        self.widgetLayout.addWidget(self.logoIamgeLabel, 0, 1)

        # 多界面
        # QListWidget + QStackedWidget实现
        self.leftListWidget = QListWidget()  # 左侧选项列表
        self.leftListWidget.setObjectName('leftListWidget')
        self.rightWidget = QStackedWidget()  # 右侧框体
        self.rightWidget.setObjectName('rightWidget')

        self.leftWidgetLayout.addWidget(self.leftListWidget)

        self.workWidgetLayout.addWidget(self.leftWidget)
        self.workWidgetLayout.addWidget(self.rightWidget)

        # ********左侧选项列表布局以及设置******************************
        # 设置左侧选项列表大小
        self.leftListWidget.setMinimumWidth(Const.LEFTWIDGET_WIDTH)
        # 左侧选项列表与右侧框体的index对应绑定
        self.leftListWidget.currentRowChanged.connect(self.rightWidget.setCurrentIndex)
        # 去掉边框
        self.leftListWidget.setFrameShape(QListWidget.NoFrame)
        # 隐藏滚动条
        self.leftListWidget.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.leftListWidget.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)

        list_str = ['智能识别', '公式生成器', '学习资源区', '设置', '关于']

        # 左侧选项添加
        for i in range(5):
            self.item = QListWidgetItem(list_str[i], self.leftListWidget)
            self.item.setSizeHint(QSize(Const.ITEM_WIDTH, Const.ITEM_HEIGHT))
            # 居中显示
            self.item.setTextAlignment(Qt.AlignCenter)

        # 设置默认选中item[1]
        self.leftListWidget.setCurrentRow(0)

        # ********右侧主框体布局以及设置**********************************
        self.rightForm1 = RightForm1()
        self.rightForm2 = RightForm2()
        self.rightForm3 = RightForm3()
        self.rightForm4 = RightForm4()
        self.rightForm5 = RightForm5()
        self.rightWidget.addWidget(self.rightForm1)
        self.rightWidget.addWidget(self.rightForm2)
        self.rightWidget.addWidget(self.rightForm3)
        self.rightWidget.addWidget(self.rightForm4)
        self.rightWidget.addWidget(self.rightForm5)

        # #############################################################
        # 消息通知框
        self.messageInform = MesageFrame()
        self.messageInform.setObjectName('messageInform')
        # 消息通知框默认隐藏
        self.messageInform.hide()

        self.mainSpiltter.addWidget(self.messageInform)

        # *****侧边栏*****
        # 右侧边栏
        self.rightBar = QFrame()
        self.rightBar.setObjectName('rightBar')
        self.rightBar.setFixedWidth(35)
        self.rightBar.setFrameShape(QFrame.StyledPanel)

        self.rightBarLayout = QVBoxLayout()
        self.rightBar.setLayout(self.rightBarLayout)

        self.workWidgetLayout.addWidget(self.rightBar)

        # 右侧边栏控件

        # 右侧边栏添加控件

        # 下侧边栏
        self.bottomBar = QFrame()
        self.bottomBar.setObjectName('bottomBar')
        self.bottomBar.setMaximumHeight(35)
        self.bottomBar.setFrameShape(QFrame.StyledPanel)

        self.bottomBarLayout = QHBoxLayout()
        self.bottomBarLayout.setAlignment(Qt.AlignRight)  # 右对齐
        self.bottomBar.setLayout(self.bottomBarLayout)

        self.mainSpiltter.addWidget(self.bottomBar)

        # 下侧边栏控件
        # 留白控件
        blank = QLabel(self.bottomBar)
        blank.setObjectName('blank')

        self.informText = QLabel(self.bottomBar)
        self.informText.setObjectName('informText')
        self.informText.setText('通知')

        self.informBtn = QPushButton(self.bottomBar)
        self.informBtn.setObjectName('informBtn')
        self.informBtn.resize(QSize(35, 35))
        self.informBtn.setIcon(QIcon('./image/mainWindowIcon/messageBarBtnIcon/inform0.png'))
        self.informBtn.clicked.connect(lambda: self.open_inform_frame())

        # 下侧边栏添加控件

        self.bottomBarLayout.addWidget(self.informBtn)
        self.bottomBarLayout.addWidget(self.informText)
        self.bottomBarLayout.addWidget(blank)

    # ****************************业务逻辑******************************
    # 右键菜单
    def show_context_menu(self):
        """
        右键点击时调用的函数
        :return:
        """
        # 显示菜单前,将它移动到鼠标点击的位置
        self.contextMenu.exec_(QCursor.pos())

    # 最小化窗口
    def show_mininized_window(self):
        """
        :return:
        """
        self.showMinimized()

    # 最大化窗口
    def show_maximized_window(self):
        """

        :return:
        """
        self.showMaximized()

    # 复原窗口
    def show_restore_window(self):
        """

        :return:
        """
        if self.isMaximized():
            self.showNormal()
        else:
            self.showMaximized()

    # 关闭窗口
    def quit_window(self):
        """

        :return:
        """
        self.close()

    # 打开文件
    def get_image(self):

        """
            getOpenFileName():返回用户所选择文件的名称,并打开该文件
            第一个参数用于指定父组件
            第二个参数指定对话框标题
            第三个参数指定目录
            第四个参数是文件扩展名过滤器
        """
        pass
        # fname, _ = QFileDialog.getOpenFileName(self, '选择图形文件', 'C:\\', "*.jpg *.gif *.png")
        # self.pixmapLabel.setPixmap(QPixmap(fname))

    def get_text(self):
        """

        :return:
        """
        pass
        # # 初始化实例,并设置一些参数
        # # textDialog = QFileDialog()
        # # textDialog.setFileMode(QFileDialog.AnyFile)
        # # textDialog.setFilter(QDir.Files)
        # textDialog = QFileDialog.getOpenFileName(self, '选择文本文件', 'C:\\', "*.txt *.doc *.docx")
        # # 当选择器关闭的时候
        # if textDialog.exec_():
        #     # 拿到所选择的文本
        #     filenames = textDialog.selectedFiles()
        #     # 读取文本内容设置到textEdit中
        #     f = open(filenames[0], 'r')
        #     with f:
        #         data = f.read()
        #         self.textEdit.setText(data)

    def open_inform_frame(self):
        self.messageInform.show()
Beispiel #59
0
class MainWindow(QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()
        self.setObjectName("myGitClone")
        root = QFileInfo.path(QFileInfo(QCoreApplication.arguments()[0]))
        print("root", root)
        self.icon = QIcon(f"{root}/favicon.ico")
        self.setWindowIcon(self.icon)
        self.setGeometry(0, 0, 800, 600)
        self.setAttribute(Qt.WA_DeleteOnClose)
        self.setMinimumSize(400, 300)
        self.setDocumentMode(True)
        self.settings = QSettings('Axel Schneider', self.objectName())
        self.createStatusbar()
        self.createActions()
        self.createWidgets()
        QMetaObject.connectSlotsByName(self)
        self.readSettings()
        self.statusbar.showMessage("Ready")
        self.setWindowTitle("myGitClone")

        ### process
        ### shell settings
        self.process = QProcess(self)
        self.process.setProcessChannelMode(QProcess.MergedChannels)
        self.process.readyReadStandardError.connect(lambda: self.msg("Error"))
        self.process.started.connect(lambda: self.msg("starting shell"))
        self.process.finished.connect(lambda: self.msg("shell ended"))

    ### widgets ###
    def createWidgets(self):
        self.username = ""
        self.url = "https://github.com/%s?tab=repositories" % self.username
        self.repoList = []
        self.gitList = []
        self.dlFolder = QDir.homePath() + "/Downloads"

        ### table ###
        self.lb = QTableWidget()
        self.lb.setColumnCount(2)
        self.lb.setColumnWidth(0, 60)
        self.lb.horizontalHeader().setStretchLastSection(True)
        self.lb.setHorizontalHeaderItem(0, QTableWidgetItem("Select"))
        self.lb.setHorizontalHeaderItem(1, QTableWidgetItem("Repository Name"))

        ### username field ###
        self.uname = QLineEdit("")
        self.uname.setFixedWidth(180)
        self.uname.setPlaceholderText("insert user name")
        self.uname.returnPressed.connect(self.listRepos)

        ### get repos button ###
        self.uBtn = QPushButton(QIcon(self.icon), "get Repos List")
        self.uBtn.setToolTip("get all repos from user")
        self.uBtn.clicked.connect(self.listRepos)

        ### get repos button ###
        self.dlBtn = QPushButton(QIcon.fromTheme("download"),
                                 "download selected Repos")
        self.dlBtn.setToolTip("download selected repos from user")
        self.dlBtn.setFixedWidth(180)
        self.dlBtn.clicked.connect(self.create_dl_list)

        ### Layout
        self.ubox = QHBoxLayout()
        self.ubox.addWidget(self.uname)
        self.ubox.addWidget(self.uBtn)
        self.ubox.addStretch(1)
        self.ubox.addWidget(self.dlBtn)

        self.layout = QVBoxLayout()
        self.wid = QWidget()

        self.layout.addLayout(self.ubox)
        self.layout.addWidget(self.lb)
        self.wid.setLayout(self.layout)

        self.setCentralWidget(self.wid)

    ### actions ###
    def createActions(self):
        self.tbar = QToolBar()
        self.tbar.setIconSize(QSize(16, 16))
        self.tbar.setMovable(False)
        self.tbar.setToolButtonStyle(0)
        self.tbar.setContextMenuPolicy(Qt.PreventContextMenu)
        self.tbar.setObjectName("tbar")
        self.addToolBar(self.tbar)

        self.actionSettings = QAction(self,
                                      triggered=self.appSettings,
                                      toolTip="set output directory")
        icon = QIcon.fromTheme("preferences-system")
        self.actionSettings.setIcon(icon)
        self.actionSettings.setObjectName("actionSettings")

        self.actionAbout = QAction(self, triggered=self.aboutApp)
        icon = QIcon.fromTheme("help-about")
        self.actionAbout.setIcon(icon)

        self.tbar.addAction(self.actionSettings)
        self.tbar.addAction(self.actionAbout)

        ### statusbar###
    def createStatusbar(self):
        self.statusbar = QStatusBar(self)
        font = QFont()
        font.setPointSize(7)
        self.statusbar.setFont(font)
        self.statusbar.setObjectName("statusbar")
        self.setStatusBar(self.statusbar)

    ### get username from textfield
    def changeUsername(self):
        self.username = self.uname.text()
        self.url = "https://github.com/%s?tab=repositories" % self.username

    ### get user repos ##
    def listRepos(self):
        self.changeUsername()
        if self.username == "":
            self.msgBox("please type a username")
        else:
            self.lb.setRowCount(0)
            self.repoList = []
            repositories = self.get_repositories()
            print("%s %s" % ("get repos from", self.username))
            self.repoList = list(repositories)
            self.fillTable()
            self.msg("repos loaded")

    ### fill table with user repos
    def fillTable(self):
        self.lb.setRowCount(len(self.repoList))
        if self.lb.rowCount() > 0:
            for x in range(len(self.repoList)):
                rep = QTableWidgetItem(self.repoList[x])
                checkbox = QCheckBox(self.lb)
                checkbox.setStyleSheet("margin-left:20%; margin-right:10%;")
                checkbox.setCheckState(0)
                self.lb.setCellWidget(x, 0, checkbox)
                self.lb.setItem(x, 1, rep)

    ### table context menu
    def contextMenuEvent(self, event):
        self.menu = QMenu(self)
        if self.lb.selectionModel().hasSelection():
            # copy
            downloadAction = QAction(QIcon.fromTheme("download"),
                                     'download Repo', self)
            downloadAction.triggered.connect(
                lambda: self.downloadRepoFromList())
            ###
            self.menu.addAction(downloadAction)
            self.menu.popup(QCursor.pos())

    def listChanged(self):
        self.create_dl_list()

    ### get download list from selected repos
    def create_dl_list(self):
        r = ""
        self.gitList = []
        for x in range(self.lb.rowCount()):
            if self.lb.cellWidget(x, 0).checkState() == 2:
                r = self.lb.item(x, 1).text()
                self.gitList.append(r)
                print("%s %s" % (r, "is selected"))
                self.downloadRepo(r)

    ### download repo
    def downloadRepo(self, gitrepo):
        merror = ""
        cmd = "git clone --progress --verbose https://github.com/" + str(
            self.username) + "/" + str(gitrepo) + " " + str(
                self.dlFolder) + "/" + str(gitrepo)
        print("%s %s" % ("username is:", self.username))
        print(cmd)
        try:
            self.process.execute(cmd)
        except Exception as e:
            s = str(e)
            self.errorBox(s)

    ### download selected repo (context menu)
    def downloadRepoFromList(self):
        row = self.lb.selectionModel().selectedIndexes()[0].row()
        gitrepo = self.lb.item(row, 1).text()
        cmd = "git clone --progress --verbose https://github.com/" + str(
            self.username) + "/" + str(gitrepo) + " " + str(
                self.dlFolder) + "/" + str(gitrepo)
        print(cmd)
        self.process.execute(cmd)

    ### preferences
    def appSettings(self):
        if self.dlFolder == "":
            self.dlFolder = QDir.homePath()
        self.msg("settings called")
        path = QFileDialog.getExistingDirectory(self, "select Folder",
                                                self.dlFolder)
        if path:
            self.dlFolder = path
            print("%s %s" % ("download folder changed to", self.dlFolder))

    def closeEvent(self, e):
        self.writeSettings()
        e.accept()

    ### read settings from config file
    def readSettings(self):
        print("reading settings")
        if self.settings.contains('geometry'):
            self.setGeometry(self.settings.value('geometry'))
        if self.settings.contains('downloadFolder'):
            self.dlFolder = self.settings.value('downloadFolder')
            self.msg(self.dlFolder)
            print("%s %s" % ("download folder:", self.dlFolder))

    ### write settings to config file
    def writeSettings(self):
        print("writing settings")
        self.settings.setValue('geometry', self.geometry())
        self.settings.setValue('downloadFolder', self.dlFolder)

    ### about window
    def aboutApp(self):
        title = "about myGitClone"
        message = """
                    <span style='color: #3465a4; font-size: 18pt;font-weight: bold;'
                    >myGitClone</strong></span></p>
                    <h3>based on <a title='git_clones' href='https://github.com/rootVIII/git_clones' target='_blank'> git_clones</a> by James</h3>
                    <h4>created by  <a title='Axel Schneider' href='http://goodoldsongs.jimdo.com' target='_blank'>Axel Schneider</a> with PyQt5</h3>
                    <br>
                    <span style='color: #555753; font-size: 9pt;'>©2019 Axel Schneider, James</strong></span></p>
                        """
        self.infobox(title, message)

    ### error messagebox
    def errorBox(self, message):
        mwin = QMessageBox.warning(self, "Error", message)

    ### messagebox
    def infobox(self, title, message):
        QMessageBox.about(self, title, message).show()

    ### set statusbar text
    def msg(self, message):
        self.statusbar.showMessage(message)

    def msgBox(self, message):
        msg = QMessageBox.warning(self, "Information", message)

    ### begin from git_clones ###
    def http_get(self):
        if version_info[0] != 2:
            req = urlopen(self.url)
            return req.read().decode('utf-8')
        req = Request(self.url)
        request = urlopen(req)
        return request.read()

    def get_repo_data(self):
        try:
            response = self.http_get()
        except Exception as e:
            s = str(e)
            self.errorBox(s)
            print("Unable to make request to %s's Github page" % self.username)
            exit(1)
        else:
            pattern = r"<a\s?href\W+%s/(.*)\"\s+" % self.username
            for line in findall(pattern, response):
                yield line.split('\"')[0]

    def get_repositories(self):
        return set([repo for repo in self.get_repo_data()])
Beispiel #60
0
class db_source(QWidget):
    def __init__(self):

        super().__init__()
        self.initUI()

    def initUI(self):
        self.main_layout = QVBoxLayout(self)
        self.Main_window()
        self.setGeometry(500, 500, 500, 300)
        self.setWindowTitle('Students_Data')
        self.tempo_dict = {}
        self.show()

#main window

    def Main_window(self):
        self.sub_widget1 = QWidget(self)
        grid = QGridLayout(self)
        self.add_widget(self.sub_widget1, grid)

        srch_bar = QLineEdit(self)
        grid.addWidget(srch_bar, 0, 0)
        self.pick_db_file()
        srch_btn = QPushButton("Search", self)
        grid.addWidget(srch_btn, 0, 1)

        self.results = QListWidget(self)
        grid.addWidget(self.results, 1, 0, 1, 2)

        view_btn = QPushButton("View Table", self)
        view_btn.clicked.connect(self.modify_window)
        grid.addWidget(view_btn, 2, 0)

        self.open_btn = QPushButton("Open", self)
        self.open_btn.setMenu(self.menu)
        self.open_btn.clicked.connect(self.pick_db_file)
        grid.addWidget(self.open_btn, 2, 1)

        crt_btn = QPushButton("Create Table", self)
        crt_btn.clicked.connect(self.createtable_window)
        grid.addWidget(crt_btn, 3, 0)

#createtable window

    def createtable_window(self):

        self.replace_widget(self.sub_widget1)
        self.sub_widget2 = QWidget(self)
        self.grid = QGridLayout(self)
        self.add_widget(self.sub_widget2, self.grid)

        self.main_layout.addWidget(self.sub_widget2)

        self.grid.addWidget(QLabel("Table Name:", self), 0, 0)
        self.Tname = QLineEdit(self)
        self.grid.addWidget(self.Tname, 0, 1)
        self.grid.addWidget(QLabel("Columns numer:", self), 1, 0)
        self.col_no = QLineEdit(self)
        self.grid.addWidget(self.col_no, 1, 1)

        self.submit_btn = QPushButton('submit', self)
        self.submit_btn.clicked.connect(self.get_columns)
        self.grid.addWidget(self.submit_btn, 2, 1)

#modification window

    def modify_window(self):
        self.get_user_columns()

        #make decision betwwen the edit mode or create mode onto the modification window
        try:
            if self.sub_widget1:
                print("bug here")
                self.replace_widget(self.sub_widget1)
                self.edit = True
            if self.sub_widget2:
                print("bug there")
                self.replace_widget(self.sub_widget2)
                self.edit = False
                self.create = True
        except AttributeError as e:
            print("cant replace widget tha is not created")

        self.sub_widget3 = QWidget(self)
        Glayout = QGridLayout(self)
        self.add_widget(self.sub_widget3, Glayout)

        #search section in modification window
        LMname = QLabel("Enter name:", self)
        Glayout.addWidget(LMname, 0, 0)
        self.SSname = QLineEdit(self)
        Glayout.addWidget(self.SSname, 0, 1)
        Searchbtn = QPushButton("Search", self)
        Searchbtn.clicked.connect(self.retrive_data)
        Glayout.addWidget(Searchbtn, 0, 2)

        #edit mode in modification window
        if self.edit:
            self.Notice = QLabel("NOTE:", self)
            Glayout.addWidget(self.Notice, 1, 1)

            Lname = QLabel("Name:", self)
            Glayout.addWidget(Lname, 2, 0)
            self.SName = QLineEdit(self)
            Glayout.addWidget(self.SName, 2, 1)

            Lid = QLabel("ID:", self)
            Glayout.addWidget(Lid, 3, 0)
            self.SId = QLineEdit(self)
            Glayout.addWidget(self.SId, 3, 1)

            Lage = QLabel("Age", self)
            Glayout.addWidget(Lage, 4, 0)
            self.SAge = QLineEdit(self)
            Glayout.addWidget(self.SAge, 4, 1)

            Lmajor = QLabel("Major:", self)
            Glayout.addWidget(Lmajor, 5, 0)
            self.SMajor = QLineEdit(self)
            Glayout.addWidget(self.SMajor, 5, 1)
            num = 5
#create mode in modification window
        elif self.create:
            form_layout = QFormLayout(self)
            for key, value in self.tempo_dict.items():
                form_layout.addRow(QLabel(value, self), QLineEdit(self))
            Glayout.addLayout(form_layout, 1, 0, 1, 3)
            num = int(self.col_no.text()) + 1

#modification window buttons
        self.Submitbtn = QPushButton("Submit", self)
        self.Submitbtn.clicked.connect(self.get_new_data)
        Glayout.addWidget(self.Submitbtn, num, 0)
        Deletebtn = QPushButton("Delete", self)
        Deletebtn.clicked.connect(self.delete_all_data)
        Glayout.addWidget(Deletebtn, num, 1)
        Cancelbtn = QPushButton("Cancel", self)
        Cancelbtn.clicked.connect(self.cancel_operation)
        Glayout.addWidget(Cancelbtn, num, 2)
        self.tempo_dict.clear()

#this picks datbase file thart exist in databse folder

    def pick_db_file(self):
        self.menu = QMenu(self)
        for file in os.scandir(
                r'/home/judethaddeus/myprojects/py_projects/dbmanager'):
            partten = r'(\.db)$'
            matches = re.findall(partten, file.name)
            for _ in range(len(matches)):
                action = self.menu.addAction(file.name)
                action.triggered.connect(self.pull_dbfile)

#this pulls bdfile and asign if ready to be used in database system

    def pull_dbfile(self):
        source = self.sender()
        dbsource2.conn = dbsource2.get_dbFile(source.text())
        dbsource2.c = dbsource2.conn.cursor()
        print(source.text())
        self.Present_Table()

#this pick new data from edit window

    def get_new_data(self):
        print(self.SName.text())
        Sdata = dbsource2.Student(self.SName.text(), self.SId.text(),
                                  self.SAge.text(), self.SMajor.text())
        dbsource2.Insert_data_tuple(Sdata)
        self.clear_field(self.SName, self.SId, self.SAge, self.SMajor)

#this read data from the database and present them on the view

    def retrive_data(self):
        dbsource2.container
        dbsource2.Select_allData(self.SSname.text())
        if not dbsource2.container:
            self.Notice.clear()
            self.Notice.setText(f"No results found for : {self.SSname.text()}")
            self.Notice.setStyleSheet("color:red")
            return
        self.SName.setText(dbsource2.container[0])
        self.SId.setText(dbsource2.container[1])
        self.SAge.setText(str(dbsource2.container[2]))
        self.SMajor.setText(dbsource2.container[3])
        try:
            self.Submitbtn.clicked.disconnect(self.get_new_data)
            self.Submitbtn.setText("Update")
            self.Submitbtn.clicked.connect(self.Update_chages)
        except:
            pass
        dbsource2.container.clear()

#this update changes by picking updates from display section

    def Update_chages(self):
        self.Submitbtn.setText("Submit")
        self.Submitbtn.clicked.disconnect(self.Update_chages)
        self.Submitbtn.clicked.connect(self.get_new_data)
        Modified_data = dbsource2.Student(self.SName.text(), self.SId.text(),
                                          self.SAge.text(), self.SMajor.text())
        print(Modified_data)
        dbsource2.Update_data(Modified_data, self.SSname.text())
        self.clear_field(self.SSname, self.SName, self.SId, self.SAge,
                         self.SMajor)
#this cleans the edit field as well delete target content from database

    def delete_all_data(self):
        dbsource2.Delete_data_Name(self.SSname.text())
        self.clear_field(self.SSname, self.SName, self.SId, self.SAge,
                         self.SMajor)

#this read all table from database and present it on display

    def Present_Table(self):
        self.clear_field(self.results, dbsource2.ss)
        dbsource2.Read_all_contents()
        for row in dbsource2.ss:
            self.results.addItem(str(row))
        print("Table presented")

#this cancels operation    and return to the main window

    def cancel_operation(self):
        try:
            self.replace_widget(self.sub_widget1)
            self.replace_widget(self.sub_widget2)
            self.replace_widget(self.sub_widget3)

        except AttributeError as e:
            print("this replace any previous widget to home widget")
        finally:
            self.Main_window()

#this colects columns name sa specified by user so to create table

    def get_columns(self):
        from PyQt5.QtCore import QRect
        cols = int(self.col_no.text())
        layout_item = self.grid.itemAtPosition(3, 0)
        if layout_item:
            print(layout_item.itemAt(0).widget().text())
            self.grid.removeItem(layout_item)
            layout_item.setGeometry(QRect(0, 0, 0, 0))
        self.tempo_dict = {}
        form_layout = QFormLayout(self)
        for i in range(cols):
            col_key = QLineEdit(self)
            self.tempo_dict[col_key] = ''
            form_layout.addRow(QLabel(f"Column {i+1}", self), col_key)
        self.grid.addLayout(form_layout, 3, 0, 1, 2)

        create_btn = QPushButton("create", self)
        create_btn.clicked.connect(self.modify_window)
        self.grid.addWidget(create_btn, 4, 0, 1, 2)

#this removes formar widget ready to add new one

    def replace_widget(self, widget):
        self.main_layout.removeWidget(widget)
        widget.hide()

#this add new widget to main layout

    def add_widget(self, widget, layout):
        self.main_layout.addWidget(widget)
        widget.setLayout(layout)
        widget.show()

#this stores the column name specified by user so to be used later

    def get_user_columns(self):
        for key, val in self.tempo_dict.items():
            self.tempo_dict[key] = key.text()


#this clear contenst ni various field or methods

    def clear_field(self, *fields):
        for field in fields:
            field.clear()