def __init__(self, dockwidget): super(Widget, self).__init__(dockwidget) self._document = None self._fileSelector = QComboBox(editable=True, insertPolicy=QComboBox.NoInsert) gadgets.drag.ComboDrag(self._fileSelector).role = Qt.UserRole self._fileSelector.lineEdit().setReadOnly(True) self._fileSelector.lineEdit().setFocusPolicy(Qt.NoFocus) self._stopButton = QToolButton() self._playButton = QToolButton() self._timeSlider = QSlider(Qt.Horizontal, tracking=False, singleStep=500, pageStep=5000, invertedControls=True) self._display = Display() self._tempoFactor = QSlider(Qt.Vertical, minimum=-50, maximum=50, singleStep=1, pageStep=5) grid = QGridLayout(spacing=0) self.setLayout(grid) grid.addWidget(self._fileSelector, 0, 0, 1, 3) grid.addWidget(self._stopButton, 1, 0) grid.addWidget(self._playButton, 1, 1) grid.addWidget(self._timeSlider, 1, 2) grid.addWidget(self._display, 2, 0, 1, 3) grid.addWidget(self._tempoFactor, 0, 3, 3, 1) # size policy of combo p = self._fileSelector.sizePolicy() p.setHorizontalPolicy(QSizePolicy.Ignored) self._fileSelector.setSizePolicy(p) # size policy of combo popup p = self._fileSelector.view().sizePolicy() p.setHorizontalPolicy(QSizePolicy.MinimumExpanding) self._fileSelector.view().setSizePolicy(p) self._player = player.Player() self._outputCloseTimer = QTimer(interval=60000, singleShot=True, timeout=self.closeOutput) self._timeSliderTicker = QTimer(interval=200, timeout=self.updateTimeSlider) self._fileSelector.activated[int].connect(self.slotFileSelected) self._tempoFactor.valueChanged.connect(self.slotTempoChanged) self._timeSlider.valueChanged.connect(self.slotTimeSliderChanged) self._timeSlider.sliderMoved.connect(self.slotTimeSliderMoved) self._player.beat.connect(self.updateDisplayBeat) self._player.time.connect(self.updateDisplayTime) self._player.stateChanged.connect(self.slotPlayerStateChanged) self.slotPlayerStateChanged(False) dockwidget.mainwindow().currentDocumentChanged.connect(self.loadResults) app.documentLoaded.connect(self.slotDocumentLoaded) app.jobFinished.connect(self.slotUpdatedFiles) app.aboutToQuit.connect(self.stop) midihub.aboutToRestart.connect(self.slotAboutToRestart) midihub.settingsChanged.connect(self.clearMidiSettings, -100) midihub.settingsChanged.connect(self.readMidiSettings) app.documentClosed.connect(self.slotDocumentClosed) app.translateUI(self) self.readMidiSettings() d = dockwidget.mainwindow().currentDocument() if d: self.loadResults(d)
def drawSpan(self, painter, rect): opt = QStyleOptionSlider() QSlider.initStyleOption(self, opt) # area groove = self.style().subControlRect(QStyle.CC_Slider, opt, QStyle.SC_SliderGroove, self) if opt.orientation == QtCore.Qt.Horizontal: groove.adjust(0, 0, -1, 0) else: groove.adjust(0, 0, 0, -1) # pen & brush painter.setPen(QPen(self.gradientLeftColor, 0)) if opt.orientation == QtCore.Qt.Horizontal: self.setupPainter(painter, opt.orientation, groove.center().x(), groove.top(), groove.center().x(), groove.bottom()) else: self.setupPainter(painter, opt.orientation, groove.left(), groove.center().y(), groove.right(), groove.center().y()) # draw groove intersected = QtCore.QRectF(rect.intersected(groove)) gradient = QLinearGradient(intersected.topLeft(), intersected.topRight()) gradient.setColorAt(0, self.gradientLeft) gradient.setColorAt(1, self.gradientRight) painter.fillRect(intersected, gradient)
def createUI(self): """Set up the user interface, signals & slots """ self.widget = QWidget(self) self.setCentralWidget(self.widget) # In this widget, the video will be drawn if sys.platform == "darwin": # for MacOS from PyQt5.QtWidgets import QMacCocoaViewContainer self.videoframe = QMacCocoaViewContainer(0) else: self.videoframe = QFrame() self.palette = self.videoframe.palette() self.palette.setColor (QPalette.Window, QColor(0,0,0)) self.videoframe.setPalette(self.palette) self.videoframe.setAutoFillBackground(True) self.positionslider = QSlider(Qt.Horizontal, self) self.positionslider.setToolTip("Position") self.positionslider.setMaximum(1000) self.positionslider.sliderMoved.connect(self.setPosition) self.hbuttonbox = QHBoxLayout() self.playbutton = QPushButton("Play") self.hbuttonbox.addWidget(self.playbutton) self.playbutton.clicked.connect(self.PlayPause) self.stopbutton = QPushButton("Stop") self.hbuttonbox.addWidget(self.stopbutton) self.stopbutton.clicked.connect(self.Stop) self.hbuttonbox.addStretch(1) self.volumeslider = QSlider(Qt.Horizontal, self) self.volumeslider.setMaximum(100) self.volumeslider.setValue(self.mediaplayer.audio_get_volume()) self.volumeslider.setToolTip("Volume") self.hbuttonbox.addWidget(self.volumeslider) self.volumeslider.valueChanged.connect(self.setVolume) self.vboxlayout = QVBoxLayout() self.vboxlayout.addWidget(self.videoframe) self.vboxlayout.addWidget(self.positionslider) self.vboxlayout.addLayout(self.hbuttonbox) self.widget.setLayout(self.vboxlayout) open = QAction("&Open", self) open.triggered.connect(self.OpenFile) exit = QAction("&Exit", self) exit.triggered.connect(sys.exit) menubar = self.menuBar() filemenu = menubar.addMenu("&File") filemenu.addAction(open) filemenu.addSeparator() filemenu.addAction(exit) self.timer = QTimer(self) self.timer.setInterval(200) self.timer.timeout.connect(self.updateUI)
def createBottomRightGroupBox(self): self.bottomRightGroupBox = QGroupBox("Group 3") self.bottomRightGroupBox.setCheckable(True) self.bottomRightGroupBox.setChecked(True) lineEdit = QLineEdit('s3cRe7') lineEdit.setEchoMode(QLineEdit.Password) spinBox = QSpinBox(self.bottomRightGroupBox) spinBox.setValue(50) dateTimeEdit = QDateTimeEdit(self.bottomRightGroupBox) dateTimeEdit.setDateTime(QDateTime.currentDateTime()) slider = QSlider(Qt.Horizontal, self.bottomRightGroupBox) slider.setValue(40) scrollBar = QScrollBar(Qt.Horizontal, self.bottomRightGroupBox) scrollBar.setValue(60) dial = QDial(self.bottomRightGroupBox) dial.setValue(30) dial.setNotchesVisible(True) layout = QGridLayout() layout.addWidget(lineEdit, 0, 0, 1, 2) layout.addWidget(spinBox, 1, 0, 1, 2) layout.addWidget(dateTimeEdit, 2, 0, 1, 2) layout.addWidget(slider, 3, 0) layout.addWidget(scrollBar, 4, 0) layout.addWidget(dial, 3, 1, 2, 1) layout.setRowStretch(5, 1) self.bottomRightGroupBox.setLayout(layout)
class PlayerControls(QWidget): def __init__(self, parent=None): super().__init__(parent) layout = QHBoxLayout(self) self.seek_slider = QSlider(orientation=Qt.Horizontal, parent=self) self.volume_slider = QSlider(orientation=Qt.Horizontal, maximum=1000, parent=self) self.playback_time = QLabel(parent=self) self.duration = QLabel(parent=self) layout.addWidget(self.seek_slider) layout.addWidget(self.volume_slider) layout.addWidget(self.playback_time) layout.addWidget(self.duration) self.setLayout(layout) @pyqtSlot(float) def update_seek_slider_position(self, val): if not self.seek_slider.isSliderDown(): self.seek_slider.setSliderPosition(val * 1000) @pyqtSlot(float) def update_seek_slider_maximum(self, val): self.seek_slider.setMaximum(val * 1000) @pyqtSlot(float) def update_duration(self, val): self.duration.setText('{:.2f}'.format(val)) @pyqtSlot(float) def update_playback_time(self, val): self.playback_time.setText('{:.2f}'.format(val))
def mousePressEvent(self, QMouseEvent): print("fug :-D") if QMouseEvent.button() == Qt.LeftButton: time = self.minimum() + ((self.maximum()-self.minimum()) * QMouseEvent.x()) / self.width() self.parent().seek(time) self.setValue(time) QSlider.mousePressEvent(self, QMouseEvent)
def __init__(self, window, config, callback): QSlider.__init__(self, Qt.Horizontal) self.config = config self.window = window self.callback = callback self.dyn = False self.lock = threading.RLock() self.update() self.valueChanged.connect(self.moved)
def createGUI(self): self.widget = QWidget(self) self.gvMain = MainView(self, 0, self.blocks) self.views = {key: XYZview(self, self.blocks, key) for key in ('xy', 'yz', 'zx')} self.cbSelectBox = QComboBox(self) self.pbAddBox = QPushButton("Add Box", self) self.pbDeleteBox = QPushButton("Delete selected box", self) self.slScale = QSlider(self) self.slScale.setOrientation(Qt.Horizontal) self.slScale.setRange(2, 15) self.slScale.setValue(5) self.slResolution = QSlider(self) self.slResolution.setOrientation(Qt.Horizontal) self.slResolution.setRange(1, 6) # resolution is 2**this_value self.slResolution.setValue(4) # 2**4 is 16 -- initial resolution self.turn_buttons = {'x': QPushButton("Turn around X axis", self), 'y': QPushButton("Turn around Y axis", self), 'z': QPushButton("Turn around Z axis", self)} self.swap_buttons = {'xy': QPushButton("Swap X and Y", self), 'yz': QPushButton("Swap Y and Z", self), 'zx': QPushButton("Swap Z and X", self)} self.grLayout = QGridLayout() self.grLayout.addWidget(QLabel("Main view"), 0, 0) self.grLayout.addWidget(self.gvMain, 1, 0) self.grLayout.addWidget(QLabel("Y view"), 0, 1) self.grLayout.addWidget(self.views['zx'], 1, 1) self.vbRightLayout = QVBoxLayout() self.vbRightLayout.addWidget(QLabel("Select box")) self.vbRightLayout.addWidget(self.cbSelectBox) self.vbRightLayout.addWidget(self.pbAddBox) self.vbRightLayout.addWidget(self.pbDeleteBox) self.vbRightLayout.addWidget(QLabel("Scale")) self.vbRightLayout.addWidget(self.slScale) self.vbRightLayout.addWidget(QLabel("Resolution")) self.vbRightLayout.addWidget(self.slResolution) self.vbRightLayout.addItem( QSpacerItem(0, 0, QSizePolicy.Minimum, QSizePolicy.Expanding)) for button in self.swap_buttons.values(): self.vbRightLayout.addWidget(button) for button in self.turn_buttons.values(): self.vbRightLayout.addWidget(button) self.hbMainLayout = QHBoxLayout() self.hbMainLayout.addLayout(self.grLayout, 10) self.hbMainLayout.addLayout(self.vbRightLayout, 1) self.grLayout.addWidget(QLabel("X view"), 2, 0) self.grLayout.addWidget(self.views['yz'], 3, 0) self.grLayout.addWidget(QLabel("Z view"), 2, 1) self.grLayout.addWidget(self.views['xy'], 3, 1) self.widget.setLayout(self.hbMainLayout) self.setCentralWidget(self.widget) self.setWindowTitle("Nodebox editor") self.resize(1000, 600)
class ColorConvertor(QDialog): def __init__(self,parent=None): super().__init__(parent=parent) self.colorR = 255 self.colorG = 255 self.colorB = 255 self.opacity = 255 self.color = QColor(self.colorR,self.colorG,self.colorB) #RGB rgbLayout=QFormLayout() labelR = QLabel("R") self.sliderR = QSlider(Qt.Horizontal) labelG = QLabel("G") self.sliderG = QSlider(Qt.Horizontal) labelB = QLabel("B") self.sliderB = QSlider(Qt.Horizontal) labelOpacity = QLabel("opacity") self.sliderOpacity = QSlider(Qt.Horizontal) for (l,s) in ((labelR,self.sliderR),(labelG,self.sliderG),(labelB,self.sliderB),(labelOpacity,self.sliderOpacity)): rgbLayout.addRow(l,s) s.setMinimum(0) s.setMaximum(255) s.setValue(255) s.setSingleStep(10) s.valueChanged.connect(self.changeColor) self.label = QLabel() self.label.setTextInteractionFlags(Qt.TextSelectableByMouse)#可复制 self.label.setText('''RGB:{colorR} {colorG} {colorB} HTML:#{colorR:02X}{colorG:02X}{colorB:02X} opacity:{opacity}'''.format(colorR=self.colorR,colorG=self.colorG,colorB=self.colorB,opacity=self.opacity)) mainLayout=QVBoxLayout() mainLayout.addLayout(rgbLayout) mainLayout.addWidget(self.label) self.setLayout(mainLayout) def paintEvent(self,event): painter = QPainter() painter.begin(self) painter.fillRect(event.rect(),QBrush(self.color)) painter.end() def changeColor(self,value): self.colorR = self.sliderR.value() self.colorG = self.sliderG.value() self.colorB = self.sliderB.value() self.opacity = self.sliderOpacity.value() self.color = QColor(self.colorR,self.colorG,self.colorB,self.opacity) self.label.setText('''RGB:{colorR} {colorG} {colorB} HTML:#{colorR:02X}{colorG:02X}{colorB:02X} opacity:{opacity}'''.format(colorR=self.colorR,colorG=self.colorG,colorB=self.colorB,opacity=self.opacity)) self.update()
def create_slider(self, label, idx, precision_sld, lower_bound, upper_bound, slider_fun): # create slider sld = QSlider(QtCore.Qt.Horizontal, self) sld.id = idx sld.precision = precision_sld # display label layout_disp = QHBoxLayout() sld.label = QLabel(label) sld.label.setAlignment(QtCore.Qt.AlignBottom | QtCore.Qt.AlignLeft) layout_disp.addWidget(sld.label) # display of current value sld.value = QLabel('Value: 0') sld.value.setAlignment(QtCore.Qt.AlignBottom | QtCore.Qt.AlignRight) layout_disp.addWidget(sld.value) # slider layout layout_sld = QVBoxLayout() layout_sld.addLayout(layout_disp) layout_sld.addWidget(sld) # settings sld.setFocusPolicy(QtCore.Qt.NoFocus) sld.valueChanged.connect(slider_fun) sld.setRange(int(np.round(lower_bound/precision_sld, 0)), int(np.round(upper_bound/precision_sld, 0))) return layout_sld, sld
def __init__(self, army): super().__init__() self.addLabels() self.cavSld = QSlider(Qt.Horizontal, self) self.cavSld.move(150, 40) self.infSld = QSlider(Qt.Horizontal, self) self.infSld.move(0, 40) self.addNumbers() accept = QPushButton("Accept", self) accept.move(100, 150) accept.clicked.connect(self.accept)
def __init__(self, *args): super().__init__(BrickletMotorizedLinearPoti, *args) self.mp = self.device self.cbe_position = CallbackEmulator(self.mp.get_position, None, self.cb_position, self.increase_error_count) self.current_position = CurveValueWrapper() self.slider = QSlider(Qt.Horizontal) self.slider.setRange(0, 100) self.slider.setMinimumWidth(200) self.slider.setEnabled(False) plots = [('Potentiometer Position', Qt.red, self.current_position, str)] self.plot_widget = PlotWidget('Position', plots, extra_key_widgets=[self.slider], update_interval=0.025, y_resolution=1.0) self.motor_slider = QSlider(Qt.Horizontal) self.motor_slider.setRange(0, 100) self.motor_slider.valueChanged.connect(self.motor_slider_value_changed) self.motor_hold_position = QCheckBox("Hold Position") self.motor_drive_mode = QComboBox() self.motor_drive_mode.addItem('Fast') self.motor_drive_mode.addItem('Smooth') def get_motor_slider_value(): return self.motor_slider.value() self.motor_hold_position.stateChanged.connect(lambda x: self.motor_slider_value_changed(get_motor_slider_value())) self.motor_drive_mode.currentIndexChanged.connect(lambda x: self.motor_slider_value_changed(get_motor_slider_value())) self.motor_position_label = MotorPositionLabel('Motor Target Position:') hlayout = QHBoxLayout() hlayout.addWidget(self.motor_position_label) hlayout.addWidget(self.motor_slider) hlayout.addWidget(self.motor_drive_mode) hlayout.addWidget(self.motor_hold_position) line = QFrame() line.setObjectName("line") line.setFrameShape(QFrame.HLine) line.setFrameShadow(QFrame.Sunken) layout = QVBoxLayout(self) layout.addWidget(self.plot_widget) layout.addWidget(line) layout.addLayout(hlayout)
def createEditor(self, parent, option, index): editor = QSlider(parent=parent, orientation=Qt.Horizontal) editor.setRange(0, 5) editor.setAutoFillBackground(True) editor.setTickPosition(QSlider.TicksBelow) editor.setTickInterval(1) return editor
class AudioPanSettings(SettingsSection): NAME = "Pan" ELEMENT = AudioPan def __init__(self, size, Id, parent=None): super().__init__(size, parent) self.id = Id self.panBox = QGroupBox(self) self.panBox.setGeometry(0, 0, self.width(), 80) self.panBox.setLayout(QHBoxLayout(self.panBox)) self.panSlider = QSlider(self.panBox) self.panSlider.setRange(-10, 10) self.panSlider.setPageStep(1) self.panSlider.setOrientation(Qt.Horizontal) self.panSlider.valueChanged.connect(self.pan_changed) self.panBox.layout().addWidget(self.panSlider) self.panLabel = QLabel(self.panBox) self.panLabel.setAlignment(Qt.AlignCenter) self.panBox.layout().addWidget(self.panLabel) self.panBox.layout().setStretch(0, 5) self.panBox.layout().setStretch(1, 1) self.retransaleUi() def retransaleUi(self): self.panBox.setTitle("Audio Pan") self.panLabel.setText("Center") def enable_check(self, enable): self.panBox.setCheckable(enable) self.panBox.setChecked(False) def get_configuration(self): conf = {} if not (self.panBox.isCheckable() and not self.panBox.isChecked()): conf["panorama"] = self.panSlider.value() / 10 return {self.id: conf} def set_configuration(self, conf): if conf is not None and self.id in conf: self.panSlider.setValue(conf[self.id]["panorama"] * 10) def pan_changed(self, value): if value < 0: self.panLabel.setText("Left") elif value > 0: self.panLabel.setText("Right") else: self.panLabel.setText("Center")
class ControlWidget(QWidget): def __init__(self, parent): QWidget.__init__(self, parent) self.directionSlider = QSlider(Qt.Horizontal, self) self.directionSlider.setMinimum(0) self.directionSlider.setMaximum(360) self.direction = QLCDNumber(self) self.directionSlider.valueChanged.connect(self.direction.display) self.layout = QVBoxLayout() self.setLayout(self.layout) self.layout.addWidget(self.directionSlider) self.layout.addWidget(self.direction)
def initUI(self): sld = QSlider(Qt.Horizontal, self) sld.setFocusPolicy(Qt.NoFocus) sld.setGeometry(30, 40, 100, 30) sld.valueChanged[int].connect(self.changeValue) self.label = QLabel(self) self.label.setPixmap(QPixmap('mute.png')) self.label.setGeometry(160, 40, 80, 30) self.setGeometry(300, 300, 280, 170) self.setWindowTitle('QSlider') self.show()
class AudioPanSettings(GstElementSettingsPage): NAME = 'Pan' ELEMENT = AudioPan def __init__(self, element_id, **kwargs): super().__init__(element_id) self.setLayout(QVBoxLayout()) self.layout().setAlignment(Qt.AlignTop) self.panBox = QGroupBox(self) self.panBox.setGeometry(0, 0, self.width(), 80) self.panBox.setLayout(QHBoxLayout(self.panBox)) self.layout().addWidget(self.panBox) self.panSlider = QSlider(self.panBox) self.panSlider.setRange(-10, 10) self.panSlider.setPageStep(1) self.panSlider.setOrientation(Qt.Horizontal) self.panSlider.valueChanged.connect(self.pan_changed) self.panBox.layout().addWidget(self.panSlider) self.panLabel = QLabel(self.panBox) self.panLabel.setAlignment(Qt.AlignCenter) self.panBox.layout().addWidget(self.panLabel) self.panBox.layout().setStretch(0, 5) self.panBox.layout().setStretch(1, 1) self.retransaleUi() def retransaleUi(self): self.panBox.setTitle('Audio Pan') self.panLabel.setText('Center') def enable_check(self, enable): self.panBox.setCheckable(enable) self.panBox.setChecked(False) def get_settings(self): conf = {} if not (self.panBox.isCheckable() and not self.panBox.isChecked()): conf['pan'] = self.panSlider.value() / 10 return {self.id: conf} def load_settings(self, settings): if settings is not None and self.id in settings: self.panSlider.setValue(settings[self.id]['pan'] * 10) def pan_changed(self, value): position = 'Left' if value < 0 else 'Right' if value > 0 else 'Center' self.panLabel.setText('{0} - {1}'.format(value, position))
class Window(QWidget): """ The main window of the application. Houses a media player and related controls. """ def __init__(self): super().__init__() layout = QVBoxLayout() self.slider = QSlider(Qt.Horizontal) btnOpen = QPushButton("Open") btnPlay = QPushButton("Play") self.player = QMediaPlayer() tl = Timeline(None, None) tlscroll = QScrollArea() tlscroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) tlscroll.setWidget(tl) btnOpen.clicked.connect(self.open) btnPlay.clicked.connect(self.play) self.player.durationChanged.connect(self.durationChanged) self.player.positionChanged.connect(self.positionChanged) layout.addWidget(self.slider) layout.addWidget(btnOpen) layout.addWidget(btnPlay) layout.addWidget(tlscroll) self.setLayout(layout) def open(self): fileName = QFileDialog.getOpenFileName(self, "Open File")[0] fileInfo = QFileInfo(fileName) if fileInfo.exists(): url = QUrl.fromLocalFile(fileInfo.absoluteFilePath()) self.changeMedia(QMediaContent(url)) def play(self): self.player.play() def changeMedia(self, mediaContent): self.player.setMedia(mediaContent) def durationChanged(self, duration): self.slider.setRange(0, duration) def positionChanged(self, position): self.slider.setValue(position)
def __init__(self): QWidget.__init__(self) # Handle to the image stack tiffcapture object. self._tiffCaptureHandle = None self.currentFrameIndex = None # Image frame viewer. self.viewer = ImageViewerQt() # Slider and arrow buttons for frame traversal. self.frameSlider = QSlider(Qt.Horizontal) self.prevFrameButton = QPushButton("<") self.nextFrameButton = QPushButton(">") self.currentFrameLabel = QLabel() self.prevFrameButton.clicked.connect(self.prevFrame) self.nextFrameButton.clicked.connect(self.nextFrame) self.frameSlider.valueChanged.connect(self.showFrame) # Layout. grid = QGridLayout(self) grid.addWidget(self.currentFrameLabel, 0, 0, 1, 3) grid.addWidget(self.viewer, 1, 0, 1, 3) grid.addWidget(self.prevFrameButton, 2, 0) grid.addWidget(self.frameSlider, 2, 1) grid.addWidget(self.nextFrameButton, 2, 2) grid.setContentsMargins(2, 2, 2, 2) grid.setSpacing(0)
def __init__(self, parent): super(PercentSlider, self).__init__(parent) self._slider = QSlider(Qt.Vertical, self) self._slider.setMinimum(-100) self._slider.setMaximum(100) self._slider.setValue(0) self._slider.setTickInterval(100) self._slider.setTickPosition(QSlider.TicksBothSides) self._slider.valueChanged.connect(lambda: self._spinbox.setValue(self._slider.value())) self._spinbox = QSpinBox(self) self._spinbox.setMinimum(-100) self._spinbox.setMaximum(100) self._spinbox.setValue(0) self._spinbox.valueChanged.connect(lambda: self._slider.setValue(self._spinbox.value())) self._zero_button = make_icon_button("hand-stop-o", "Zero setpoint", self, on_clicked=self.zero) layout = QVBoxLayout(self) sub_layout = QHBoxLayout(self) sub_layout.addStretch() sub_layout.addWidget(self._slider) sub_layout.addStretch() layout.addLayout(sub_layout) layout.addWidget(self._spinbox) layout.addWidget(self._zero_button) self.setLayout(layout) self.setMinimumHeight(400)
def __init__(self, element_id, **kwargs): super().__init__(element_id) self.setLayout(QVBoxLayout()) self.layout().setAlignment(Qt.AlignTop) self.panBox = QGroupBox(self) self.panBox.setGeometry(0, 0, self.width(), 80) self.panBox.setLayout(QHBoxLayout(self.panBox)) self.layout().addWidget(self.panBox) self.panSlider = QSlider(self.panBox) self.panSlider.setRange(-10, 10) self.panSlider.setPageStep(1) self.panSlider.setOrientation(Qt.Horizontal) self.panSlider.valueChanged.connect(self.pan_changed) self.panBox.layout().addWidget(self.panSlider) self.panLabel = QLabel(self.panBox) self.panLabel.setAlignment(Qt.AlignCenter) self.panBox.layout().addWidget(self.panLabel) self.panBox.layout().setStretch(0, 5) self.panBox.layout().setStretch(1, 1) self.retransaleUi()
def initPositionSlider(self): """Initialize position slider.""" self.positionSlider = QSlider(Qt.Horizontal, self) self.positionSlider.setValue(0) self.positionSlider.valueChanged[int].connect(self.position) self.positionSliderClicked = False self.grid.addWidget(self.positionSlider, 0, 0, 1, 3, Qt.AlignBottom)
def __init__(self, parent, update_callback): QWidget.__init__(self, parent) self.layout = QGridLayout() self.setLayout(self.layout) self.update_callback = update_callback self.light_value = QSlider(self) self.hue_value = QDial(self) self.saturation_value = QDial(self) self.monitor = Monitor(self) self.layout.addWidget(QLabel('Hue'), 0, 0, Qt.AlignHCenter) self.layout.addWidget(self.hue_value, 1, 0, Qt.AlignHCenter) self.layout.addWidget(QLabel('Saturation'), 2, 0, Qt.AlignHCenter) self.layout.addWidget(self.saturation_value, 3, 0, Qt.AlignHCenter) self.layout.addWidget(self.monitor, 4, 0, Qt.AlignHCenter) self.layout.addWidget(QLabel('Intensity'), 5, 0, Qt.AlignHCenter) self.layout.addWidget(self.light_value, 6, 0, Qt.AlignHCenter) self.update() self.hue_value.valueChanged.connect(self.update) self.saturation_value.valueChanged.connect(self.update) self.light_value.valueChanged.connect(self.update)
def initializeWindow(self): layout = QVBoxLayout() self.m_deviceBox = QComboBox(activated=self.deviceChanged) for deviceInfo in QAudioDeviceInfo.availableDevices(QAudio.AudioOutput): self.m_deviceBox.addItem(deviceInfo.deviceName(), deviceInfo) layout.addWidget(self.m_deviceBox) self.m_modeButton = QPushButton(clicked=self.toggleMode) self.m_modeButton.setText(self.PUSH_MODE_LABEL) layout.addWidget(self.m_modeButton) self.m_suspendResumeButton = QPushButton( clicked=self.toggleSuspendResume) self.m_suspendResumeButton.setText(self.SUSPEND_LABEL) layout.addWidget(self.m_suspendResumeButton) volumeBox = QHBoxLayout() volumeLabel = QLabel("Volume:") self.m_volumeSlider = QSlider(Qt.Horizontal, minimum=0, maximum=100, singleStep=10, valueChanged=self.volumeChanged) volumeBox.addWidget(volumeLabel) volumeBox.addWidget(self.m_volumeSlider) layout.addLayout(volumeBox) window = QWidget() window.setLayout(layout) self.setCentralWidget(window)
def __init__(self, size, Id, parent=None): super().__init__(size, parent) self.id = Id self.groupBox = QGroupBox(self) self.groupBox.setGeometry(0, 0, self.width(), 80) self.layout = QHBoxLayout(self.groupBox) self.pitchSlider = QSlider(self.groupBox) self.pitchSlider.setMinimum(-12) self.pitchSlider.setMaximum(12) self.pitchSlider.setPageStep(1) self.pitchSlider.setValue(0) self.pitchSlider.setOrientation(QtCore.Qt.Horizontal) self.pitchSlider.setTickPosition(QSlider.TicksAbove) self.pitchSlider.setTickInterval(1) self.layout.addWidget(self.pitchSlider) self.pitchLabel = QLabel(self.groupBox) self.pitchLabel.setAlignment(QtCore.Qt.AlignCenter) self.layout.addWidget(self.pitchLabel) self.layout.setStretch(0, 3) self.layout.setStretch(1, 1) self.pitchSlider.valueChanged.connect(self.pitch_changed) self.retranslateUi()
def __init__(self, orientation, title, parent=None): super(SlidersGroup, self).__init__(title, parent) self.slider = QSlider(orientation) self.slider.setFocusPolicy(Qt.StrongFocus) self.slider.setTickPosition(QSlider.TicksBothSides) self.slider.setTickInterval(10) self.slider.setSingleStep(1) self.scrollBar = QScrollBar(orientation) self.scrollBar.setFocusPolicy(Qt.StrongFocus) self.dial = QDial() self.dial.setFocusPolicy(Qt.StrongFocus) self.slider.valueChanged.connect(self.scrollBar.setValue) self.scrollBar.valueChanged.connect(self.dial.setValue) self.dial.valueChanged.connect(self.slider.setValue) self.dial.valueChanged.connect(self.valueChanged) if orientation == Qt.Horizontal: direction = QBoxLayout.TopToBottom else: direction = QBoxLayout.LeftToRight slidersLayout = QBoxLayout(direction) slidersLayout.addWidget(self.slider) slidersLayout.addWidget(self.scrollBar) slidersLayout.addWidget(self.dial) self.setLayout(slidersLayout)
def initUI(self): self.player = QMediaPlayer() self.playlist = QMediaPlaylist() vbox = QVBoxLayout() hbox = QHBoxLayout() self.setGeometry(300, 300, 290, 150) self.slider = QSlider(Qt.Horizontal) self.playBtn = QPushButton('►') self.nextBtn = QPushButton('>') self.prevBtn = QPushButton('<') self.nextBtn.clicked.connect(self.nextSong) self.prevBtn.clicked.connect(self.prevSong) self.playBtn.clicked.connect(self.playSong) self.setWindowTitle('VK music') self.list = QListWidget(self) self.list.currentItemChanged.connect(self.selectSong) for track in self.vk.method('audio.get').get('items'): self.list.addItem(SongWidgetItem(track)) self.playlist.addMedia(QMediaContent(QUrl(track['url']))) hbox.addWidget(self.prevBtn) hbox.addWidget(self.playBtn) hbox.addWidget(self.nextBtn) hbox.addWidget(self.slider) self.player.setPlaylist(self.playlist) self.player.positionChanged.connect(self.setPosition) vbox.addWidget(self.list) vbox.addLayout(hbox) self.setLayout(vbox) self.show()
def __init__(self, parent=None, display_status=False): super(VideoPlayer, self).__init__(parent) self.display_status = display_status self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface) self.videoItem = QGraphicsVideoItem() scene = QGraphicsScene(self) graphicsView = QGraphicsView(scene) scene.addItem(self.videoItem) self.playButton = QPushButton() self.playButton.setEnabled(False) self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay)) self.playButton.clicked.connect(self.play) self.positionSlider = QSlider(Qt.Horizontal) self.positionSlider.setRange(0, 0) self.positionSlider.sliderMoved.connect(self.setPosition) if self.display_status: self.status_mapping = { QMediaPlayer.UnknownMediaStatus: "UnknownMediaStatus", QMediaPlayer.NoMedia: "NoMedia", QMediaPlayer.LoadingMedia: "LoadingMedia", QMediaPlayer.LoadedMedia: "LoadedMedia", QMediaPlayer.StalledMedia: "StalledMedia", QMediaPlayer.BufferingMedia: "BufferingMedia", QMediaPlayer.BufferedMedia: "BufferedMedia", QMediaPlayer.EndOfMedia: "EndOfMedia", QMediaPlayer.InvalidMedia: "InvalidMedia" } self.statusText = QPlainTextEdit() self.statusText.setReadOnly(True) self.statusText.setFixedHeight(25) self.statusText.setFixedWidth(150) self.mediaPlayer.mediaStatusChanged.connect(self.mediaStatusChanged) controlLayout = QHBoxLayout() controlLayout.setContentsMargins(0, 0, 0, 0) controlLayout.addWidget(self.playButton) controlLayout.addWidget(self.positionSlider) if self.display_status: controlLayout.addWidget(self.statusText) layout = QVBoxLayout() layout.addWidget(graphicsView) layout.addLayout(controlLayout) self.setFixedWidth(WIDTH + WIGGLE) self.setLayout(layout) self.mediaPlayer.setVideoOutput(self.videoItem) self.mediaPlayer.stateChanged.connect(self.mediaStateChanged) self.mediaPlayer.positionChanged.connect(self.positionChanged) self.mediaPlayer.durationChanged.connect(self.durationChanged)
def __init__(self, data_manager, pca): super(FitterDialog, self).__init__() self.setupUi(self) self.setAttribute(Qt.WA_DeleteOnClose) assert isinstance(data_manager, DataManager) self.data_manager = data_manager self.pca = pca self.active_shape_model = ActiveShapeModel(self.data_manager, self.pca) self.initial_pose_model = InitialPoseModel(self.data_manager) self.scene = InteractiveGraphicsScene() self.graphicsView.setScene(self.scene) self.scene.clicked.connect(self._set_position) self.image = self.data_manager.radiographs[0].image self.radiograph_image = Filter.crop_image(self.data_manager.radiographs[0].image) self.openButton.clicked.connect(self._open_radiograph) self.exportButton.clicked.connect(self._export_result) self.exportButton.setEnabled(False) self.zoomSlider.setRange(-10, 10) self.zoomSlider.setValue(self.current_scale) self.zoomSlider.valueChanged.connect(self.change_scale) self.levelSlider.setRange(1, MultiResolutionFramework.levels_count) self.levelSlider.setValue(self.current_sampling_level + 1) self.levelSlider.valueChanged.connect(self.user_change_level) self.stepButton.clicked.connect(self._perform_one_step_asm) self.animateButton.clicked.connect(self._animator_entry) self._scales = np.empty(self.pca.eigen_values.shape) for i, deviation in enumerate(self.pca.get_allowed_deviation()): slider = QSlider(Qt.Horizontal, self.paramsScrollAreaContents) slider.setRange(-self.slider_resolution, self.slider_resolution) # slider.valueChanged.connect(self.slider_moved) self.paramsScrollAreaContents.layout().addWidget(slider) self._scales[i] = deviation / self.slider_resolution self.show_sampled_positions = self.sampledPositionsCheckBox.isChecked() self.sampledPositionsCheckBox.stateChanged.connect(self.change_show_positions) self.startingPoseSpinBox.setMaximum(len(self.data_manager.selector)-1) self._redraw(self.active_shape_model.current_tooth)
def initUI(self): self.setFixedSize(400, 260) self.setWindowTitle('Fomoire!') fomoire = QPixmap(os.path.join('./Pictures/', "fomoire.png")) logo = QLabel(self) logo.setPixmap(fomoire) logo.setFixedSize(fomoire.size()) logo.move(400 / 2 - fomoire.width() / 2, 15) towerDefence = QLabel('A Tower Defence Game', self) towerDefence.move(130, 66) selectMap = QLabel('Select map:', self) selectMap.move(50, 105) mapList = QComboBox(self) mapList.addItem('No map selected') for mapFile in os.listdir('./Maps/'): mapList.addItem(mapFile) mapList.move(135, 102) mapList.activated[str].connect(self.selectMap) setSpeed = QLabel('Set game speed:', self) setSpeed.move(50, 140) slow = QLabel('Slow', self) slow.move(170, 140) slider = QSlider(Qt.Horizontal, self) slider.setFocusPolicy(Qt.NoFocus) slider.setSliderPosition(100 - self.gameSpeed) slider.setGeometry(210, 140, 100, 20) slider.valueChanged[int].connect(self.changeGameSpeed) fast = QLabel('Fast', self) fast.move(325, 140) start = QPushButton('Start game!', self) start.move(145, 175) start.clicked[bool].connect(self.startGame) quitButton = QPushButton('Quit', self) quitButton.move(168, 210) quitButton.clicked[bool].connect(qApp.quit) barbarian = QLabel(self) brbr = QPixmap(os.path.join('./Pictures/', "barbarian.png")) barbarian.setPixmap(brbr) barbarian.move(70, 185) berserker = QLabel(self) berber = QPixmap(os.path.join('./Pictures/', "berserker_left.png")) berserker.setPixmap(berber) berserker.move(290, 185) self.show()
def __init__(self): self.inital_completed = False self.threadpool = QThreadPool() self.lock = Lock() self.video_stream = None root = Tk() root.withdraw() self.root_dir = askdirectory( initialdir="/", title="Select root directory containing all cage folders") if self.root_dir is (): raise AssertionError else: self.database_local_dir = 'database/homecage_database.sqlite' self.F = None super().__init__() self.widget_main = QWidget() self.play_speed = 0 self.image_label = QLabel() self.image_label.resize(1280, 720) self.radio_group = [ QRadioButton('Unlabeled'), QRadioButton('Labeled') ] self.components_left = [ QLabel("Cage"), QComboBox(), QLabel("Animal"), QComboBox(), QLabel("Date"), QLabel("From"), QCalendarWidget(), QLabel("Till"), QCalendarWidget(), QLabel("Video List || Double click :)"), QListWidget() ] self.components_right_low = [ QPushButton('Play(space)'), QPushButton('Speed(q): %d' % self.play_speed), QPushButton('Next Frame (d)'), QPushButton('Previous Frame (a)'), QPushButton('Start Labeling (s)'), QPushButton('Clean all labels') ] for i in range(len(self.components_right_low)): self.components_right_low[i].setDisabled(True) self.Playing_Flag = False self.layout_main = QGridLayout() self.layout_left = QVBoxLayout() self.layout_radio = QHBoxLayout() self.layout_right_high = QVBoxLayout() self.layout_right_low = QHBoxLayout() self.widget_main.setLayout(self.layout_main) for component in self.components_left: self.layout_left.addWidget(component) for component in self.components_right_low: self.layout_right_low.addWidget(component) for radio in self.radio_group: self.layout_radio.addWidget(radio) self.slider = QSlider(Qt.Horizontal) self.slider.setTickPosition(QSlider.TicksBothSides) self.slider.setTickInterval(10) self.slider.setSingleStep(1) self.slider.setValue(0) self.radio_group[0].setChecked(True) self.layout_right_high.addWidget(self.image_label) self.layout_right_high.addWidget(self.slider) self.components_left[6].setMaximumDate(datetime.datetime.now()) self.components_left[8].setMaximumDate(datetime.datetime.now()) self.min_date = datetime.datetime.now() self.max_date = datetime.datetime.now() self.layout_left.addLayout(self.layout_radio) self.layout_main.addLayout(self.layout_left, 0, 0, 4, 1) self.layout_main.addLayout(self.layout_right_high, 0, 2, 4, 4) self.layout_main.addLayout(self.layout_right_low, 4, 2, 5, 5) self.setCentralWidget(self.widget_main) self.overlay = Overlay(self.centralWidget()) self.overlay.show() self.show() self.thread_get_cages() self.components_left[1].currentIndexChanged.connect( self.on_select_cage) self.components_left[3].currentIndexChanged.connect( self.on_select_animal) self.components_left[6].selectionChanged.connect( self.on_select_date_min) self.components_left[8].selectionChanged.connect( self.on_select_date_max) self.components_left[10].itemDoubleClicked.connect( self.on_select_video) self.components_left[10].setSelectionMode( QListWidget.SingleSelection) self.slider.sliderMoved.connect(self.on_slider) self.slider.sliderReleased.connect(self.on_slider_release) self.components_right_low[0].clicked.connect(self.on_play) self.components_right_low[1].clicked.connect(self.on_speed) self.components_right_low[2].clicked.connect(self.on_next_frame) self.components_right_low[3].clicked.connect( self.on_previous_frame) self.components_right_low[4].clicked.connect(self.on_labeling) self.components_right_low[5].clicked.connect(self.on_clean_all) for i in range(len(self.radio_group)): self.radio_group[i].clicked.connect( lambda: self.on_radio(self.radio_group[i])) self.init_image = cv2.imread(os.path.join("pic", "init.jpg")) self.init_image = cv2.cvtColor(self.init_image, cv2.COLOR_BGR2RGB) self.init_image = cv2.resize(self.init_image, (1280, 720)) self.th = imageThread() self.th.changePixmap.connect(self.update_image) self.th.start() self.th.frames_queue.put(self.init_image) self.animal = "" self.index = 0 self.inital_completed = True self.start_frame = 0 self.end_frame = 0 self.event_dict = { 0: "Knock Down", 1: "Attemp", 2: "Success", 3: "Successful Lick", 4: "Discard this event" } self.current_video_list_all = [] self.current_video_list_unlabeled = [] self.current_video_list_labeled = [] self.video_path = None self.slider_queue = Queue() self.thread_update_slider() self.thread_update_database()
class LoadDataDialog(QDialog): """Dialog box that contains a data preview for a 3d HDF5 dataset. Preview window allows selection of a ROI using a mouse or manual input. An estimated data size is calculated based upon ROI size and downsampling factor. """ def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.data_limits = None self.roi_changed = False self.setWindowTitle("Select Data to Load") main_layout = QVBoxLayout() main_layout.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter) self.setLayout(main_layout) container = QWidget(self) hbox = QHBoxLayout(container) container.setMaximumWidth(950) container.setMaximumHeight(530) container.setLayout(hbox) container.setObjectName("loaderContainer") container.setStyleSheet( "QWidget#loaderContainer {" " background-color: #fefefe; " " border-radius: 10px;" "}" ) lvbox = QVBoxLayout() rvbox = QVBoxLayout() lvbox.setAlignment(Qt.AlignTop) rvbox.setAlignment(Qt.AlignTop) hbox.addLayout(lvbox, 1) hbox.addLayout(rvbox, 1) main_layout.addWidget(container) lvbox.addWidget(QLabel("Preview Dataset")) slider_vbox = self.setup_slider() lvbox.addLayout(slider_vbox) self.canvas = MplCanvas() self.canvas.roi_updated.connect(self.on_roi_box_update) lvbox.addWidget(self.canvas) # INPUT rvbox.addWidget(QLabel("Input Dataset:")) self.winput = FileWidget(extensions=LOAD_DATA_EXT, save=False) rvbox.addWidget(self.winput) rvbox.addWidget(QLabel("Internal HDF5 data path:")) self.int_h5_pth = QLabel("None selected") rvbox.addWidget(self.int_h5_pth) roi_fields = self.setup_roi_fields() rvbox.addWidget(QWidget(), 1) rvbox.addWidget(roi_fields) # Save | Cancel buttons = QDialogButtonBox.Ok | QDialogButtonBox.Cancel self.buttonBox = QDialogButtonBox(buttons) self.buttonBox.accepted.connect(self.accept) self.buttonBox.rejected.connect(self.reject) rvbox.addWidget(self.buttonBox) self.winput.path_updated.connect(self.load_data) self.slider.sliderReleased.connect(self.update_image) self.slider.valueChanged.connect(self.update_slider_z_label) def setup_roi_fields(self): """Setup the dialog fields associated with ROI selection. Returns: PyQt5.QWidgets.QGroupBox: The GroupBox containing the fields. """ apply_roi_button = QPushButton("Apply ROI") reset_button = QPushButton("Reset ROI") roi_fields = QGroupBox("Select Region of Interest:") roi_layout = QGridLayout() roi_layout.addWidget( QLabel("Drag a box in the image window or type manually"), 0, 0, 1, 3 ) roi_layout.addWidget(QLabel("Axis"), 1, 0) roi_layout.addWidget(QLabel("Start Value:"), 1, 1) roi_layout.addWidget(QLabel("End Value:"), 1, 2) roi_layout.addWidget(apply_roi_button, 1, 3) roi_layout.addWidget(reset_button, 2, 3) roi_layout.addWidget(QLabel("x:"), 2, 0) self.xstart_linedt = QLineEdit("0") self.xstart_linedt.textChanged.connect(self.on_roi_param_changed) roi_layout.addWidget(self.xstart_linedt, 2, 1) self.xend_linedt = QLineEdit("0") self.xend_linedt.textChanged.connect(self.on_roi_param_changed) roi_layout.addWidget(self.xend_linedt, 2, 2) roi_layout.addWidget(QLabel("y:"), 3, 0) self.ystart_linedt = QLineEdit("0") self.ystart_linedt.textChanged.connect(self.on_roi_param_changed) roi_layout.addWidget(self.ystart_linedt, 3, 1) self.yend_linedt = QLineEdit("0") self.yend_linedt.textChanged.connect(self.on_roi_param_changed) roi_layout.addWidget(self.yend_linedt, 3, 2) roi_layout.addWidget(QLabel("z:"), 4, 0) self.zstart_linedt = QLineEdit("0") self.zstart_linedt.textChanged.connect(self.on_roi_param_changed) roi_layout.addWidget(self.zstart_linedt, 4, 1) self.zend_linedt = QLineEdit("0") self.zend_linedt.textChanged.connect(self.on_roi_param_changed) roi_layout.addWidget(self.zend_linedt, 4, 2) roi_layout.addWidget(QLabel("Downsample Factor:"), 5, 0) self.downsample_spinner = QSpinBox() self.downsample_spinner.setRange(1, 10) self.downsample_spinner.setSpecialValueText("None") self.downsample_spinner.setMaximumWidth(60) self.downsample_spinner.valueChanged.connect(self.on_roi_param_changed) roi_layout.addWidget(self.downsample_spinner, 5, 1) roi_layout.addWidget(QLabel("Estimated datasize (MB):"), 5, 3) self.data_size_label = QLabel("0") roi_layout.addWidget(self.data_size_label, 5, 4) roi_fields.setLayout(roi_layout) apply_roi_button.clicked.connect(self.on_roi_apply_clicked) reset_button.clicked.connect(self.on_roi_reset_clicked) return roi_fields def setup_slider(self): """Creates a horizontal slider in a VBoX with labels showing max and min values. Returns: PyQt5.QWidgets.QVBoxLayout: A QVBoXLayout containing the slider and labels. """ self.slider = QSlider(1) slider_vbox = QVBoxLayout() slider_hbox = QHBoxLayout() slider_hbox.setContentsMargins(0, 0, 0, 0) slider_vbox.setContentsMargins(0, 0, 0, 0) slider_vbox.setSpacing(0) self.slider_min_label = QLabel(alignment=Qt.AlignLeft) self.slider_z_label = QLabel(alignment=Qt.AlignCenter) self.slider_max_label = QLabel(alignment=Qt.AlignRight) slider_vbox.addWidget(self.slider) slider_vbox.addLayout(slider_hbox) slider_hbox.addWidget(self.slider_min_label, Qt.AlignLeft) slider_hbox.addWidget(self.slider_z_label, Qt.AlignCenter) slider_hbox.addWidget(self.slider_max_label, Qt.AlignRight) slider_vbox.addStretch() return slider_vbox @pyqtSlot() def update_slider_z_label(self): """Changes Z value label when slider moved.""" idx = self.sender().value() self.slider_z_label.setNum(idx) @pyqtSlot() def on_roi_reset_clicked(self): """Resets data preview and ROI fields when reset button clicked.""" self.data_limits = None self.reset_roi_fields() self.update_image(load=True) @pyqtSlot() def on_roi_apply_clicked(self): """Updates data preview window to fit new ROI when 'Apply' button clicked.""" self.data_limits = self.get_roi_limits() self.roi_changed = self.check_if_roi_changed(self.data_limits) self.update_image() @pyqtSlot() def on_roi_param_changed(self): """Gets ROI limits and updates estimated data size whenever value is changed.""" limits = self.get_roi_limits() x_start, x_end, y_start, y_end, z_start, z_end = self.clip_roi_box_vals(limits) x_size = x_end - x_start y_size = y_end - y_start z_size = z_end - z_start self.update_est_data_size(z_size, y_size, x_size) def get_roi_limits(self): """Reads the values of the ROI parameter fields. Returns: tuple: The six parameters x_start, x_end, y_start, y_end, z_start, z_end defining a 3d ROI """ x_start = self.get_linedt_value(self.xstart_linedt) x_end = self.get_linedt_value(self.xend_linedt) y_start = self.get_linedt_value(self.ystart_linedt) y_end = self.get_linedt_value(self.yend_linedt) z_start = self.get_linedt_value(self.zstart_linedt) z_end = self.get_linedt_value(self.zend_linedt) return x_start, x_end, y_start, y_end, z_start, z_end def get_linedt_value(self, linedt): """Helper function that converts text in a LineEdit to int if it exists Args: linedt (PyQt5.QWidgets.LineEdit): A linedit widget to read. Returns: int: Value of text in LineEdt or 0 """ if linedt.text(): return int(linedt.text()) return 0 def load_data(self, path): """Launches dialog box to select dataset from within HDF5 file and loads in data if selected. Args: path (str): Path to the HDF5 file. """ if path is not None and len(path) > 0: dataset = None if path.endswith(".h5") or path.endswith(".hdf5"): available_hdf5 = self.available_hdf5_datasets(path) selected, accepted = ComboDialog.getOption( available_hdf5, parent=self, title="HDF5: Select internal path" ) if accepted == QDialog.Rejected: return dataset = selected self.int_h5_pth.setText(selected) self.data = self.volread(path) self.dataset = dataset if isinstance(self.data, h5.Group): self.data_shape = self.data[self.dataset].shape else: self.data_shape = self.data.shape logger.info(self.data_shape) self.reset_roi_fields() self.update_image(load=True) def reset_roi_fields(self): """Resets all the ROI dimension parameters to equal the data shape.""" self.xstart_linedt.setText("0") self.xend_linedt.setText(str(self.data_shape[2])) self.ystart_linedt.setText("0") self.yend_linedt.setText(str(self.data_shape[1])) self.zstart_linedt.setText("0") self.zend_linedt.setText(str(self.data_shape[0])) self.roi_changed = False def check_if_roi_changed(self, roi_limits): """Checks if any of the ROI dimension parameters are different from the data shape. Args: roi_limits (tuple): The six parameters x_start, x_end, y_start, y_end, z_start, z_end defining a 3d ROI Returns: bool: True if the ROI dimension parameters are different from the data shape. """ x_start, x_end, y_start, y_end, z_start, z_end = roi_limits if not x_start == y_start == z_start == 0: return True if ( (x_end != self.data_shape[2]) or (y_end != self.data_shape[1]) or (z_end != self.data_shape[0]) ): return True return False def on_roi_box_update(self, size_tuple): """Updates ROI dimension parameters with data from ROI box drawn by dragging mouse on preview window. Args: size_tuple (tuple): Tuple of values received from ROI box, x_start, x_end, y_start, y_end """ # Append the z values z_start = int(self.zstart_linedt.text()) z_end = int(self.zend_linedt.text()) size_tuple += (z_start, z_end) # Clip the values x_start, x_end, y_start, y_end, z_start, z_end = self.clip_roi_box_vals( size_tuple ) self.xstart_linedt.setText(str(x_start)) self.xend_linedt.setText(str(x_end)) self.ystart_linedt.setText(str(y_start)) self.yend_linedt.setText(str(y_end)) self.zstart_linedt.setText(str(z_start)) self.zend_linedt.setText(str(z_end)) def clip_roi_box_vals(self, vals): """Clip ROI values to ensure that they lie within the data shape. Args: vals (tuple): Tuple of six ROI parameters x_start, x_end, y_start, y_end, z_start, z_end Returns: tuple: Tuple of six clipped ROI parameters x_start, x_end, y_start, y_end, z_start, z_end """ x_start, x_end, y_start, y_end, z_start, z_end = map(round, vals) x_start, x_end = clip([x_start, x_end], 0, self.data_shape[2]) y_start, y_end = clip([y_start, y_end], 0, self.data_shape[1]) z_start, z_end = clip([z_start, z_end], 0, self.data_shape[0]) return x_start, x_end, y_start, y_end, z_start, z_end def volread(self, path): """Helper to return a file handle to an HDF5 file. Args: path (str): Path to the HDF5 file. Raises: Exception: If the file is not and HDF5 file. Returns: h5py.File: File handle to an HDF5 file. """ _, file_extension = os.path.splitext(path) data = None logger.info("Loading file handle") if file_extension in [".hdf5", ".h5"]: data = h5.File(path, "r") elif file_extension in [".tif", ".tiff"]: data = io.imread(path) elif file_extension in [".rec", ".mrc"]: mrc = mrcfile.mmap(path, mode="r+") data = mrc.data else: raise Exception("File format not supported") return data def scan_datasets_group(self, group, shape=None, dtype=None, path=""): """Recursive function that finds the datasets in an HDF5 file. Args: group (h5py.File or h5py.Group): A File Handle (Root Group) or Group. shape (tuple, optional): Specify datasets of a certain shape. Defaults to None. dtype (str, optional): Specify datasets of certain type. Defaults to None. path (str, optional): Internal HDF5 path. Defaults to ''. Returns: list: The datasets contained with the HDF5 file. """ datasets = [] for name, ds in group.items(): curr_path = "{}/{}".format(path, name) if hasattr(ds, "shape"): if ( len(ds.shape) == 3 and (shape is None or ds.shape == shape) and (dtype is None or ds.dtype == dtype) ): datasets.append(curr_path) else: extra = self.scan_datasets_group(ds, shape=shape, path=curr_path) if len(extra) > 0: datasets += extra return datasets def available_hdf5_datasets(self, path, shape=None, dtype=None): """Wrapper round the scan_datasets_gruop function.""" datasets = [] with h5.File(path, "r") as f: datasets = self.scan_datasets_group(f, shape=shape, dtype=dtype) return datasets @pyqtSlot() def update_image(self, load=False): """Updates the image in the preview window. Args: load (bool, optional): Set to True if loading a new dataset. Defaults to False. """ # Only update index if called by slider if isinstance(self.sender(), QSlider): idx = self.sender().value() else: idx = None # Set limits if self.data_limits: x_start, x_end, y_start, y_end, z_start, z_end = self.data_limits x_size = x_end - x_start y_size = y_end - y_start z_size = z_end - z_start else: z_size, y_size, x_size = self.data_shape x_start, x_end, y_start, y_end, z_start, z_end = ( 0, x_size, 0, y_size, 0, z_size, ) # Show central slice if loading data or changing roi if idx is None or load: idx = z_size // 2 self.slider.blockSignals(True) self.slider.setMinimum(z_start) self.slider_min_label.setNum(z_start) self.slider.setMaximum(z_end - 1) self.slider_max_label.setNum(z_end) self.slider.setValue(idx) self.slider_z_label.setNum(idx) self.slider.blockSignals(False) self.canvas.ax.set_ylim([y_size + 1, -1]) self.canvas.ax.set_xlim([-1, x_size + 1]) if isinstance(self.data, h5.Group): img = self.data[self.dataset][idx] else: img = self.data[idx] self.canvas.ax.imshow(img[y_start:y_end, x_start:x_end], "gray") self.canvas.ax.grid(False) self.canvas.redraw() def update_est_data_size(self, z_size, y_size, x_size): """Updates the estimated datasize label according to the dimensions and the downsampling factor. Args: z_size (int): Length of z dimension. y_size (int): Length of y dimension. x_size (int): Length of x dimension. """ data_size_tup = tuple(map(int, (z_size, y_size, x_size))) est_data_size = (product(data_size_tup) * 4) / 10 ** 6 est_data_size /= self.downsample_spinner.value() self.data_size_label.setText(f"{est_data_size:.2f}")
def add_options_panel(self): # Prepare the sliders options_layout = QVBoxLayout() options_layout.addStretch() # Centralize the sliders sliders_layout = QVBoxLayout() max_label_width = -1 # Get min and max for all dof ranges = [] for i in range(self.model.nbSegment()): seg = self.model.segment(i) for r in seg.QRanges(): ranges.append([r.min(), r.max()]) for i in range(self.model.nbQ()): slider_layout = QHBoxLayout() sliders_layout.addLayout(slider_layout) # Add a name name_label = QLabel() name = f"{self.model.nameDof()[i].to_string()}" name_label.setText(name) name_label.setPalette(self.palette_active) label_width = name_label.fontMetrics().boundingRect( name_label.text()).width() if label_width > max_label_width: max_label_width = label_width slider_layout.addWidget(name_label) # Add the slider slider = QSlider(Qt.Horizontal) slider.setMinimumSize(100, 0) slider.setMinimum(ranges[i][0] * self.double_factor) slider.setMaximum(ranges[i][1] * self.double_factor) slider.setPageStep(self.double_factor) slider.setValue(0) slider.valueChanged.connect(self.__move_avatar_from_sliders) slider.sliderReleased.connect( partial(self.__update_muscle_analyses_graphs, False, False, False, False)) slider_layout.addWidget(slider) # Add the value value_label = QLabel() value_label.setText(f"{0:.2f}") value_label.setPalette(self.palette_active) slider_layout.addWidget(value_label) # Add to the main sliders self.sliders.append((name_label, slider, value_label)) # Adjust the size of the names for name_label, _, _ in self.sliders: name_label.setFixedWidth(max_label_width + 1) # Put the sliders in a scrollable area sliders_widget = QWidget() sliders_widget.setLayout(sliders_layout) sliders_scroll = QScrollArea() sliders_scroll.setFrameShape(0) sliders_scroll.setWidgetResizable(True) sliders_scroll.setWidget(sliders_widget) options_layout.addWidget(sliders_scroll) # Add reset button button_layout = QHBoxLayout() options_layout.addLayout(button_layout) reset_push_button = QPushButton("Reset") reset_push_button.setPalette(self.palette_active) reset_push_button.released.connect(self.reset_q) button_layout.addWidget(reset_push_button) # Add the radio button for analyses option_analyses_group = QGroupBox() option_analyses_layout = QVBoxLayout() # Add text analyse_text = QLabel() analyse_text.setPalette(self.palette_active) analyse_text.setText("Analyses") option_analyses_layout.addWidget(analyse_text) # Add the no analyses radio_none = QRadioButton() radio_none.setPalette(self.palette_active) radio_none.setChecked(True) radio_none.toggled.connect( lambda: self.__select_analyses_panel(radio_none, 0)) radio_none.setText("None") option_analyses_layout.addWidget(radio_none) # Add the muscles analyses radio_muscle = QRadioButton() radio_muscle.setPalette(self.palette_active) radio_muscle.toggled.connect( lambda: self.__select_analyses_panel(radio_muscle, 1)) radio_muscle.setText("Muscles") option_analyses_layout.addWidget(radio_muscle) # Add the layout to the interface option_analyses_group.setLayout(option_analyses_layout) options_layout.addWidget(option_analyses_group) # Finalize the options panel options_layout.addStretch() # Centralize the sliders # Animation panel animation_layout = QVBoxLayout() animation_layout.addWidget(self.vtk_window.avatar_widget) # Add the animation slider animation_slider_layout = QHBoxLayout() animation_layout.addLayout(animation_slider_layout) load_push_button = QPushButton("Load movement") load_push_button.setPalette(self.palette_active) load_push_button.released.connect(self.__load_movement_from_button) animation_slider_layout.addWidget(load_push_button) # Controllers self.play_stop_push_button = QPushButton() self.play_stop_push_button.setIcon(self.start_icon) self.play_stop_push_button.setPalette(self.palette_active) self.play_stop_push_button.setEnabled(False) self.play_stop_push_button.released.connect( self.__start_stop_animation) animation_slider_layout.addWidget(self.play_stop_push_button) slider = QSlider(Qt.Horizontal) slider.setMinimum(0) slider.setMaximum(100) slider.setValue(0) slider.setEnabled(False) slider.valueChanged.connect(self.__animate_from_slider) animation_slider_layout.addWidget(slider) self.record_push_button = QPushButton() self.record_push_button.setIcon(self.record_icon) self.record_push_button.setPalette(self.palette_active) self.record_push_button.setEnabled(True) self.record_push_button.released.connect(self.__record) animation_slider_layout.addWidget(self.record_push_button) self.stop_record_push_button = QPushButton() self.stop_record_push_button.setIcon(self.stop_icon) self.stop_record_push_button.setPalette(self.palette_active) self.stop_record_push_button.setEnabled(False) self.stop_record_push_button.released.connect(self.__stop_record, True) animation_slider_layout.addWidget(self.stop_record_push_button) # Add the frame count frame_label = QLabel() frame_label.setText(f"{0}") frame_label.setPalette(self.palette_inactive) animation_slider_layout.addWidget(frame_label) self.movement_slider = (slider, frame_label) # Global placement of the window self.vtk_window.main_layout.addLayout(options_layout, 0, 0) self.vtk_window.main_layout.addLayout(animation_layout, 0, 1) self.vtk_window.main_layout.setColumnStretch(0, 1) self.vtk_window.main_layout.setColumnStretch(1, 2) # Change the size of the window to account for the new sliders self.vtk_window.resize(self.vtk_window.size().width() * 2, self.vtk_window.size().height()) # Prepare all the analyses panel self.muscle_analyses = MuscleAnalyses(self.analyses_muscle_widget, self) if biorbd.currentLinearAlgebraBackend() == 1: radio_muscle.setEnabled(False) else: if self.model.nbMuscles() == 0: radio_muscle.setEnabled(False) self.__select_analyses_panel(radio_muscle, 1)
class Player(QMainWindow): """ A simple Media Player using VLC and Qt """ def __init__(self, master=None): super().__init__() self.setWindowTitle("CCTV by @XII") # creating a basic vlc instance self.instance = vlc.Instance() # creating an empty vlc media player self.mediaplayer = self.instance.media_player_new() self.path = '' self.initUI() self.isPaused = False self.setStyleSheet(open("style.qss", "r").read()) def initUI(self): """ Set up the user interface, signals & slots For better understaning, I made some shortcuts for variables, which is the instance of the QtWidgets classes. List of shortcuts(made): *btn - QPushButton; *lbl - QLabel; *slr - QSlider; *lyt - Q_lyt; *ctrl - ctrl; """ self.widget = QWidget(self) self.setCentralWidget(self.widget) #video widget self.videoframe = QFrame() self.palette = self.videoframe.palette() self.palette.setColor(QtGui.QPalette.Window, QtGui.QColor(0, 0, 0)) self.videoframe.setPalette(self.palette) self.videoframe.setAutoFillBackground(True) #time value self.timevalue = QDateTimeEdit() self.timevalue.setDisplayFormat('hh:mm:ss') self.timevalue.setReadOnly(True) self.timevalue.setFixedSize(80, 30) #position slider self.position_slr = QSlider(QtCore.Qt.Horizontal, self) self.position_slr.setToolTip("Position") self.position_slr.setMaximum(1000) self.position_slr.sliderMoved.connect(self.set_position) #play button self.play_btn = QPushButton() self.play_btn.setProperty("onplay", True) self.play_btn.setObjectName("play") self.play_btn.clicked.connect(self.play_pause) #stop button self.stop_btn = QPushButton() self.stop_btn.setObjectName('stop') self.stop_btn.clicked.connect(self.stop) #analyse button self.analyse_btn = QPushButton('Analyse') self.analyse_btn.setObjectName('analyse') self.analyse_btn.setFixedSize(70, 28) self.analyse_btn.clicked.connect(self.start_analyse) self.analyse_window = Analyse(self) self.analyse_window.off() self.analyse_btn.setEnabled(False) self.on_analyse = False self.details_btn = QPushButton('Details') self.details_btn.setVisible(False) self.details_btn.setObjectName('details') self.details_btn.setFixedSize(70, 28) self.details_btn.clicked.connect(self.show_details) self.details_wd = pictureViewer() self.details_wd.close() self.threadpool = QtCore.QThreadPool() self.threadpool.setMaxThreadCount(1) worker = loadModules(self) self.threadpool.start(worker) self.path_input = pathLineEdit(self) self.path_input.setObjectName('path') self.folder_btn = QPushButton() self.folder_btn.setObjectName('folder') self.folder_btn.clicked.connect( lambda x: self.select_folder(foldername='')) self.fileslist_lbl = QLabel('Playlist:') self.fileslist_lbl.setObjectName('lbl') self.fileslist_lbl.setIndent(12) self.fileslist = QListWidget() self.fileslist.itemClicked.connect(self.select_file) self.warnings_lbl = QLabel('Warnings time:') self.warnings_lbl.setObjectName('lbl') self.warnings_lbl.setIndent(12) self.warningslist = QListWidget() #volume slider self.volume_slr = QSlider(QtCore.Qt.Horizontal, self) self.volume_slr.setMaximum(100) self.volume_slr.setValue(self.mediaplayer.audio_get_volume()) self.volume_slr.setToolTip("Volume") self.volume_slr.valueChanged.connect(self.set_volume) #setting up layouts folder_lyt = QHBoxLayout() folder_lyt.addWidget(self.path_input) folder_lyt.addWidget(self.folder_btn) leftside_lyt = QVBoxLayout() leftside_lyt.setContentsMargins(0, 10, 0, 0) leftside_lyt.addSpacing(6) leftside_lyt.addWidget(self.fileslist_lbl) leftside_lyt.addWidget(self.fileslist) analyse_btns = QHBoxLayout() analyse_btns.addWidget(self.details_btn) analyse_btns.addWidget(self.analyse_btn) leftside_lyt.addLayout(analyse_btns) leftside_lyt.addWidget(self.warnings_lbl) leftside_lyt.addWidget(self.warningslist) leftside_lyt.addLayout(folder_lyt) leftside_lyt.addSpacing(6) self.leftside_bg = QWidget() self.leftside_bg.setObjectName("leftside_bg") self.leftside_bg.setLayout(leftside_lyt) ctrl_lyt = QHBoxLayout() ctrl_lyt.addSpacing(20) ctrl_lyt.addWidget(self.play_btn) ctrl_lyt.setSpacing(0) ctrl_lyt.addWidget(self.stop_btn) ctrl_lyt.addStretch(1) ctrl_lyt.addWidget(self.volume_slr) ctrl_panel_lyt = QVBoxLayout() ctrl_panel_lyt.setContentsMargins(60, 12, 60, 12) ctrl_panel_lyt.addWidget(self.timevalue, 0, QtCore.Qt.AlignLeft) ctrl_panel_lyt.addWidget(self.position_slr) ctrl_panel_lyt.addLayout(ctrl_lyt) rightside_lyt = QVBoxLayout() rightside_lyt.addWidget(self.videoframe) rightside_lyt.addLayout(ctrl_panel_lyt) main_lyt = QHBoxLayout() main_lyt.setSpacing(0) main_lyt.setContentsMargins(0, 0, 0, 0) main_lyt.addWidget(self.leftside_bg) main_lyt.addLayout(rightside_lyt, 60) self.widget.setLayout(main_lyt) self.timer = QtCore.QTimer(self) self.timer.setInterval(200) self.timer.timeout.connect(self.updateUI) #creates connection to db self.db = db_api.create_connection( os.path.join(os.getcwd(), 'db', 'data.db')) def play_pause(self): """ Toggle play/pause status """ if self.mediaplayer.is_playing(): self.mediaplayer.pause() self.play_btn.setProperty("onplay", True) self.play_btn.setStyle(self.play_btn.style()) self.isPaused = True else: if self.mediaplayer.play() == -1: return self.mediaplayer.play() self.play_btn.setProperty("onplay", False) self.play_btn.setStyle(self.play_btn.style()) self.timer.start() self.isPaused = False def start_analyse(self): self.analyse_btn.setEnabled(False) try: file = self.fileslist.currentItem().text() except AttributeError: self.analyse_btn.setEnabled(True) QMessageBox.information(self, "Warning!", "You should to select a file.") return if not self.on_analyse: self.setEnabled(False) self.analyse_window.on() try: worker = AnalyseWorker(file, self) self.threadpool.start(worker) except Exception as e: print(e) else: return def show_details(self): try: file = self.fileslist.currentItem().text() except AttributeError: self.analyse_btn.setEnabled(True) QMessageBox.information(self, "Warning!", "You should to select a file.") return item = self.fileslist.currentItem().text() if os.path.isdir(os.path.join('warnings', os.path.splitext(item)[0])): self.details_wd.show() self.details_wd.start(self.fileslist.currentItem().text()) else: return def stop_analyse(self): self.analyse_window.off() self.setEnabled(True) self.on_analyse = False def stop(self): """ stop player """ if self.mediaplayer.is_playing(): self.timevalue.setTime(QtCore.QTime.fromMSecsSinceStartOfDay(0)) self.mediaplayer.stop() def select_file(self, item): self.open_file(filename=self.path + '/' + item.text()) def check_warnings_time(self, filename): with self.db: file_id = db_api.select_file(self.db, filename) if file_id: #if file in db, then add warning times in list bellow timelist = db_api.select_time(self.db, file_id) self.warningslist.clear() for time in timelist: self.warningslist.addItem(time[0] + "-" + time[1]) self.details_btn.setVisible(True) else: self.details_btn.setVisible(False) self.warningslist.clear() self.warningslist.addItem("There is nothing to show.") def open_file(self, filename=''): """ Open a media file in a MediaPlayer """ if filename == '': filename = QFileDialog.getOpenFileName(self, "Open File", './')[0] if not filename: return self.check_warnings_time(os.path.split(filename)[1]) # create the media self.media = self.instance.media_new(filename) # put the media in the media player self.mediaplayer.set_media(self.media) # parse the metadata of the file self.media.parse_async() fullpath = re.escape(filename) # get video duration time = os.popen("ffmpeg -i {0}".format(fullpath) + " 2>&1 | grep Duration | awk '{print $2}' | tr -d ," ).read().split(':') self.duration = int(3600000 * int(time[0]) + 60000 * int(time[1]) + 1000 * float(time[2])) # set the title of the track as window title self.setWindowTitle("CCTV: " + self.media.get_meta(0)) # the media player has to be 'connected' to the QFrame # (otherwise a video would be displayed in it's own window) # this is platform specific! # you have to give the id of the QFrame (or similar object) to # vlc, different platforms have diffqerent functions for this if sys.platform == "linux": # for Linux using the X Server self.mediaplayer.set_xwindow(self.videoframe.winId()) elif sys.platform == "win32": # for Windows self.mediaplayer.set_hwnd(self.videoframe.winId()) elif sys.platform == "darwin": # for MacOS self.mediaplayer.set_agl(self.videoframe.windId()) self.play_pause() def set_volume(self, Volume): """ Set the volume """ self.mediaplayer.audio_set_volume(Volume) def set_position(self, position): """ Set the position """ # setting the position to where the slider was dragged self.mediaplayer.set_position(position / 1000.0) # the vlc MediaPlayer needs a float value between 0 and 1, Qt # uses integer variables, so you need a factor; the higher the # factor, the more precise are the results # (1000 should be enough) self.timevalue.setTime( QtCore.QTime.fromMSecsSinceStartOfDay( self.mediaplayer.get_position() * self.duration)) def set_time(self, time): """ Set time to display """ self.mediaplayer.set_time(time) def select_folder(self, foldername=''): if foldername == '': foldername = str( QFileDialog.getExistingDirectory(self, "Select Directory")) self.path_input.setText(foldername) self.path = foldername if not foldername: return files = os.listdir(foldername) self.path = foldername self.fileslist.clear() for file in files: self.fileslist.addItem(file) def updateUI(self): """ updates the user interface """ # setting the slider to the desired position self.position_slr.setValue(self.mediaplayer.get_position() * 1000) self.timevalue.setTime( QtCore.QTime.fromMSecsSinceStartOfDay( self.mediaplayer.get_position() * self.duration)) self.volume_slr.setValue(self.mediaplayer.audio_get_volume()) if not self.mediaplayer.is_playing(): # no need to call this function if nothing is played self.timer.stop() if not self.isPaused: # after the video finished, the play button stills shows # "Pause", not the desired behavior of a media player # this will fix it self.stop()
class MainScreen(QMainWindow): """The Main GUI layout and callbacks. """ def __init__(self) -> None: logging.info("Initialize MainScreen") super().__init__(parent=None) self._traffic: Optional[Traffic] = None self._tview: Optional[Traffic] = None self.decoder: Optional[ModeS_Decoder] = None self.updateTraffic: Optional[UpdateTraffic] = None self.airspace_ready: bool = False self.last_interact: datetime = datetime.now() airspace_init = AirspaceInitCache(self) airspace_init.start() self.setWindowTitle("traffic") self.setGeometry(10, 10, 920, 720) self.set_icons() self.set_layout() self.set_design() self.set_callbacks() def __del__(self) -> None: if self.updateTraffic is not None: self.updateTraffic.terminate() if self.decoder is not None: self.decoder.stop() @property def traffic(self) -> Optional[Traffic]: self.last_interact = datetime.now() if self.decoder is not None: self._traffic = self.decoder.traffic if self._traffic is None: return None self.set_time_range() # self.set_float_columns() # max_alt = 100 * self.altitude_slider.value() # max_time = self.dates[self.time_slider.value()] # self.on_filter(max_alt, max_time) return self._traffic def set_callbacks(self) -> None: self.airport_button.clicked.connect(self.on_plot_airport) self.altitude_slider.sliderMoved.connect(self.on_altitude_moved) self.altitude_slider.sliderReleased.connect(self.on_select) self.area_input.textEdited.connect(self.on_area_input) self.area_select.itemSelectionChanged.connect(self.on_area_select) self.extent_button.clicked.connect(self.on_extent_button) self.identifier_input.textEdited.connect(self.on_id_input) self.identifier_select.itemSelectionChanged.connect(self.on_id_change) self.open_dropdown.activated.connect(self.on_open) self.plot_button.clicked.connect(self.on_plot_button) self.projection_dropdown.activated.connect(self.make_map) self.reset_button.clicked.connect(self.on_clear_button) self.time_slider.sliderMoved.connect(self.on_time_moved) self.time_slider.sliderReleased.connect(self.on_select) self.y_selector.itemSelectionChanged.connect(self.on_id_change) self.sec_y_selector.itemSelectionChanged.connect(self.on_id_change) def set_design(self) -> None: self.open_dropdown.setMaximumWidth(400) self.projection_dropdown.setMaximumWidth(400) self.altitude_description.setMinimumWidth(100) self.altitude_description.setMaximumWidth(100) self.altitude_slider_info.setMinimumWidth(50) self.altitude_slider_info.setMaximumWidth(50) self.altitude_slider.setMaximumWidth(240) self.area_input_description.setMinimumWidth(100) self.area_input_description.setMaximumWidth(100) self.area_input.setMaximumWidth(290) self.area_select.setMaximumHeight(100) self.area_select.setMaximumWidth(400) self.identifier_description.setMinimumWidth(100) self.identifier_description.setMaximumWidth(100) self.identifier_input.setMaximumWidth(290) self.identifier_select.setMaximumWidth(400) self.time_description.setMinimumWidth(100) self.time_description.setMaximumWidth(100) self.time_slider_info.setMinimumWidth(50) self.time_slider_info.setMaximumWidth(50) self.time_slider.setMaximumWidth(240) self.y_selector.setMaximumHeight(100) self.sec_y_selector.setMaximumHeight(100) def set_layout(self) -> None: self.plot_tabs = QTabWidget() map_tab = QWidget() map_layout = QVBoxLayout() map_tab.setLayout(map_layout) self.map_plot = MapCanvas(parent=self, width=5, height=4) self.map_plot.move(0, 0) self.time_plot = TimeCanvas(parent=self, width=5, height=4) self.time_plot.move(0, 0) map_toolbar = NavigationToolbar2QT(self.map_plot, map_tab) map_toolbar.setVisible(False) map_layout.addWidget(map_toolbar) map_layout.addWidget(self.map_plot) map_toolbar.pan() time_tab = QWidget() time_layout = QVBoxLayout() time_tab.setLayout(time_layout) self.y_selector = QListWidget() self.sec_y_selector = QListWidget() self.y_selector.setSelectionMode(3) # extended selection self.sec_y_selector.setSelectionMode(3) # extended selection selector = QHBoxLayout() selector.addWidget(self.y_selector) selector.addWidget(self.sec_y_selector) time_layout.addLayout(selector) time_layout.addWidget(self.time_plot) self.plot_tabs.addTab(map_tab, "Map") self.plot_tabs.addTab(time_tab, "Plots") plot_column = QVBoxLayout() plot_column.addWidget(self.plot_tabs) self.interact_column = QVBoxLayout() self.open_options = ["Open file", "dump1090"] if "decoders" in config: self.open_options += list(config["decoders"]) self.open_dropdown = QComboBox() for option in self.open_options: self.open_dropdown.addItem(option) self.interact_column.addWidget(self.open_dropdown) self.projections = ["EuroPP", "Lambert93", "Mercator"] self.projection_dropdown = QComboBox() more_projs = config.get("projections", "extra", fallback="") if more_projs != "": proj_list = more_projs.split(";") self.projections += list(x.strip() for x in proj_list) for proj in self.projections: self.projection_dropdown.addItem(proj) self.interact_column.addWidget(self.projection_dropdown) button_grid = QGridLayout() self.extent_button = QPushButton("Extent") button_grid.addWidget(self.extent_button, 0, 0) self.plot_button = QPushButton("Plot") button_grid.addWidget(self.plot_button, 0, 1) self.airport_button = QPushButton("Airport") button_grid.addWidget(self.airport_button, 1, 0) self.reset_button = QPushButton("Reset") button_grid.addWidget(self.reset_button, 1, 1) self.interact_column.addLayout(button_grid) self.area_input_description = QLabel("Area") self.area_input = QLineEdit() area_input_layout = QHBoxLayout() area_input_layout.addWidget(self.area_input_description) area_input_layout.addWidget(self.area_input) self.interact_column.addLayout(area_input_layout) self.area_select = QListWidget() self.interact_column.addWidget(self.area_select) self.time_slider = QSlider(QtCore.Qt.Horizontal) self.time_description = QLabel("Date max.") self.time_slider_info = QLabel() time_layout = QHBoxLayout() time_layout.addWidget(self.time_description) time_layout.addWidget(self.time_slider) time_layout.addWidget(self.time_slider_info) self.time_slider.setMinimum(0) self.time_slider.setMaximum(99) self.time_slider.setValue(99) self.time_slider.setEnabled(False) self.interact_column.addLayout(time_layout) self.altitude_slider = QSlider(QtCore.Qt.Horizontal) self.altitude_description = QLabel("Altitude max.") self.altitude_slider_info = QLabel("60000") self.altitude_slider.setSingleStep(5) self.altitude_slider.setPageStep(100) self.altitude_slider.setMinimum(0) self.altitude_slider.setMaximum(600) self.altitude_slider.setValue(600) altitude_layout = QHBoxLayout() altitude_layout.addWidget(self.altitude_description) altitude_layout.addWidget(self.altitude_slider) altitude_layout.addWidget(self.altitude_slider_info) self.interact_column.addLayout(altitude_layout) self.identifier_description = QLabel("Callsign/ID") self.identifier_input = QLineEdit() identifier_layout = QHBoxLayout() identifier_layout.addWidget(self.identifier_description) identifier_layout.addWidget(self.identifier_input) self.interact_column.addLayout(identifier_layout) self.identifier_select = QListWidget() self.identifier_select.setSelectionMode(3) # extended selection self.interact_column.addWidget(self.identifier_select) mainLayout = QGridLayout() mainLayout.addLayout(plot_column, 0, 0) mainLayout.addLayout(self.interact_column, 0, 1) mainWidget = QWidget() mainWidget.setLayout(mainLayout) self.setCentralWidget(mainWidget) # -- Callbacks -- @dont_crash def on_time_moved(self, value: int, *args, **kwargs) -> None: self.last_interact = datetime.now() self.time_slider_info.setText(self.date_options[value]) @dont_crash def on_altitude_moved(self, value: int, *args, **kwargs) -> None: self.last_interact = datetime.now() self.altitude_slider_info.setText(f"{100*value}") @dont_crash def on_select(self, *args, **kwargs) -> None: self.last_interact = datetime.now() if self.traffic is not None: max_alt = 100 * self.altitude_slider.value() max_time = self.dates[self.time_slider.value()] self.on_filter(max_alt, max_time) @dont_crash def on_filter(self, max_alt: int, max_time: datetime) -> None: assert self._traffic is not None west, east, south, north = self.map_plot.ax.get_extent( crs=PlateCarree()) self._tview = self._traffic.before(max_time).sort_values("timestamp") if self._tview is None: return filtered = Traffic.from_flights( Flight(f.data.ffill().bfill()) for f in self._tview) if "altitude" in filtered.data.columns: filtered = filtered.query( f"altitude != altitude or altitude <= {max_alt}") if "latitude" in self._tview.data.columns: filtered = filtered.query("latitude != latitude or " f"({west} <= longitude <= {east} and " f"{south} <= latitude <= {north})") self.identifier_select.clear() text = self.identifier_input.text() # cast is necessary because of the @lru_cache on callsigns which hides # the type annotation for callsign in sorted(cast(Set[str], filtered.callsigns)): if re.match(text, callsign, flags=re.IGNORECASE): self.identifier_select.addItem(callsign) callsigns = cast(Set[str], filtered.callsigns) self.map_plot.default_plot(self._tview[callsigns]) self.set_float_columns() @dont_crash def on_extent_button(self, *args, **kwargs) -> None: self.last_interact = datetime.now() if self.area_select.count() == 0: if len(self.area_input.text()) == 0: self.map_plot.ax.set_global() else: self.map_plot.ax.set_extent(location(self.area_input.text())) else: if self.airspace_ready: self.map_plot.ax.set_extent( aixm_airspaces[self.area_select.item(0).text()]) self.map_plot.draw() if self.traffic is not None: max_alt = 100 * self.altitude_slider.value() max_time = self.dates[self.time_slider.value()] self.on_filter(max_alt, max_time) @dont_crash def on_id_change(self, *args, **kwargs) -> None: assert self._tview is not None self.last_interact = datetime.now() list_callsigns = list( item.text() for item in self.identifier_select.selectedItems()) selected_y = list(item.text() for item in self.y_selector.selectedItems()) selected_sec_y = list(item.text() for item in self.sec_y_selector.selectedItems()) self.map_plot.plot_callsigns(self._tview, list_callsigns) self.time_plot.create_plot() self.time_plot.plot_callsigns( self._tview, list_callsigns, y=selected_y + selected_sec_y, secondary_y=selected_sec_y, ) @dont_crash def on_id_input(self, text, *args, **kwargs) -> None: assert self._tview is not None self.last_interact = datetime.now() # segfault prone when interactive (decoder) # selected = list( # item.text() for item in self.identifier_select.selectedItems() # ) self.identifier_select.clear() for callsign in sorted(cast(Set[str], self._tview.callsigns)): if re.match(text, callsign, flags=re.IGNORECASE): self.identifier_select.addItem(callsign) # if callsign in selected: # curItem = self.identifier_select.item( # self.identifier_select.count() - 1 # ) # self.identifier_select.setItemSelected(curItem, True) @dont_crash def on_plot_button(self, *args, **kwargs) -> None: assert self._tview is not None self.last_interact = datetime.now() if self.area_select.count() == 0: if len(self.area_input.text()) == 0: self.map_plot.default_plot(self._tview) else: location(self.area_input.text()).plot( self.map_plot.ax, color="#524c50", linestyle="dotted", linewidth=0.5, ) else: if self.airspace_ready: selected = self.area_select.selectedItems() if len(selected) == 0: return airspace = aixm_airspaces[selected[0].text()] if airspace is not None: airspace.plot(self.map_plot.ax) self.map_plot.draw() @dont_crash def on_area_input(self, text: str, *args, **kwargs) -> None: self.last_interact = datetime.now() self.area_select.clear() if len(text) > 0 and self.airspace_ready: for airspace_info in aixm_airspaces.parse(text): self.area_select.addItem(airspace_info.name) @dont_crash def on_area_select(self, *args, **kwargs) -> None: self.last_interact = datetime.now() selected = self.area_select.selectedItems() if len(selected) == 0: return if self.airspace_ready: airspace = aixm_airspaces[selected[0].text()] if airspace is not None: self.map_plot.ax.set_extent(airspace) self.map_plot.draw() @dont_crash def on_plot_airport(self, *args, **kwargs) -> None: self.last_interact = datetime.now() if len(self.area_input.text()) == 0: from cartotools.osm import request, tags west, east, south, north = self.map_plot.ax.get_extent( crs=PlateCarree()) if abs(east - west) > 1 or abs(north - south) > 1: # that would be a too big request return request((west, south, east, north), **tags.airport).plot(self.map_plot.ax) else: from traffic.data import airports airport = airports[self.area_input.text()] if airport is not None: airport.plot(self.map_plot.ax) self.map_plot.draw() @dont_crash def on_clear_button(self, *args, **kwargs) -> None: self.last_interact = datetime.now() if self.traffic is not None: assert self._traffic is not None self._tview = self._traffic.sort_values("timestamp") self.altitude_slider.setValue(600) self.make_map(self.projection_dropdown.currentIndex()) self.time_plot.create_plot() self.set_float_columns() @dont_crash def make_map(self, index_projection: int, *args, **kwargs) -> None: self.last_interact = datetime.now() self.map_plot.create_map(self.projections[index_projection]) if self._tview is not None: self.map_plot.default_plot(self._tview) @dont_crash def on_open(self, index: int, *args, **kwargs) -> None: if self.decoder is not None and self.updateTraffic is not None: self.updateTraffic.terminate() self.decoder.stop() if index == 0: self.openFile() elif index == 1: self.openDump1090() else: address = config.get("decoders", self.open_options[index]) host_port, reference = address.split("/") host, port = host_port.split(":") self.decoder = ModeS_Decoder.from_address(host, int(port), reference) refresh_time = config.getint("decoders", "refresh_time", fallback=30) self.updateTraffic = UpdateTraffic(self, refresh_time) self.updateTraffic.start() # -- Basic setters -- def set_icons(self) -> None: logging.info("Setting options") icon_path = Path(traffic.__file__).absolute().parent.parent / "icons" if sys.platform == "linux": icon_full = QtGui.QIcon( (icon_path / "travel-beige.svg").as_posix()) elif sys.platform == "darwin": icon_full = QtGui.QIcon((icon_path / "travel-grey.svg").as_posix()) else: icon_full = QtGui.QIcon( (icon_path / "travel-orange.svg").as_posix()) self.setWindowIcon(icon_full) def set_time_range(self) -> None: assert self._traffic is not None self.time_slider.setEnabled(True) start_time = cast(pd.Timestamp, self._traffic.start_time) end_time = cast(pd.Timestamp, self._traffic.end_time) self.dates = [ start_time + i * (end_time - start_time) / 99 for i in range(100) ] tz_now = datetime.now().astimezone().tzinfo if cast(pd.Timestamp, self._traffic.start_time).tzinfo is not None: self.date_options = [ t.tz_convert("utc").strftime("%H:%M") for t in self.dates ] else: self.date_options = [ t.tz_localize(tz_now).tz_convert("utc").strftime("%H:%M") for t in self.dates ] self.time_slider_info.setText(self.date_options[-1]) def set_float_columns(self) -> None: assert self._traffic is not None self.y_selector.clear() self.sec_y_selector.clear() for column, dtype in self._traffic.data.dtypes.items(): if column not in ("latitude", "longitude"): if dtype in ["float64", "int64"]: self.y_selector.addItem(column) self.sec_y_selector.addItem(column) def openDump1090(self) -> None: reference, ok = QInputDialog.getText(self, "dump1090 reference", "Reference airport:") if ok: self.open_dropdown.setItemText(1, f"dump1090 ({reference})") self.decoder = ModeS_Decoder.from_dump1090(reference) refresh_time = config.getint("decoders", "refresh_time", fallback=30) self.updateTraffic = UpdateTraffic(self, refresh_time) self.updateTraffic.start() @dont_crash def openFile(self, *args, **kwargs) -> None: options = { "caption": "Open file", "filter": ("Pandas DataFrame (*.pkl);;" "CSV files (*.csv);;" "Sqlite3 files (*.db)"), # "filter": "Data files (*.csv *.pkl)", "directory": os.path.expanduser("~"), } self.filename = QFileDialog.getOpenFileName(self, **options)[0] if self.filename == "": return self.filename = Path(self.filename) self._traffic = Traffic.from_file(self.filename) assert self._traffic is not None self._tview = self._traffic.sort_values("timestamp") assert self._tview is not None self.open_dropdown.setItemText(0, self.filename.name) self.map_plot.default_plot(self._tview) self.identifier_select.clear() for callsign in sorted(cast(Set[str], self._tview.callsigns)): self.identifier_select.addItem(callsign) self.set_time_range() self.set_float_columns()
def __init__(self, window, plugin, keystore, device_id): title = _("{} Settings").format(plugin.device) super(SettingsDialog, self).__init__(window, title) config = app_state.config hs_rows, hs_cols = (64, 128) def invoke_client(method, *args, **kw_args): unpair_after = kw_args.pop('unpair_after', False) def task(): client = app_state.device_manager.client_by_id(device_id) if not client: raise RuntimeError("Device not connected") if method: getattr(client, method)(*args, **kw_args) if unpair_after: app_state.device_manager.unpair_id(device_id) return client.features window.run_in_thread(task, on_success=update) def update(features): self.features = features set_label_enabled() bl_hash = bh2u(features.bootloader_hash) bl_hash = "\n".join([bl_hash[:32], bl_hash[32:]]) noyes = [_("No"), _("Yes")] endis = [_("Enable Passphrases"), _("Disable Passphrases")] disen = [_("Disabled"), _("Enabled")] setchange = [_("Set a PIN"), _("Change PIN")] version = "%d.%d.%d" % (features.major_version, features.minor_version, features.patch_version) device_label.setText(features.label) pin_set_label.setText(noyes[features.pin_protection]) passphrases_label.setText(disen[features.passphrase_protection]) bl_hash_label.setText(bl_hash) label_edit.setText(features.label) device_id_label.setText(features.device_id) initialized_label.setText(noyes[features.initialized]) version_label.setText(version) clear_pin_button.setVisible(features.pin_protection) clear_pin_warning.setVisible(features.pin_protection) pin_button.setText(setchange[features.pin_protection]) pin_msg.setVisible(not features.pin_protection) passphrase_button.setText(endis[features.passphrase_protection]) language_label.setText(features.language) def set_label_enabled(): label_apply.setEnabled(label_edit.text() != self.features.label) def rename(): invoke_client('change_label', label_edit.text()) def toggle_passphrase(): title = _("Confirm Toggle Passphrase Protection") currently_enabled = self.features.passphrase_protection if currently_enabled: msg = _("After disabling passphrases, you can only pair this " "ElectrumSV wallet if it had an empty passphrase. " "If its passphrase was not empty, you will need to " "create a new wallet with the install wizard. You " "can use this wallet again at any time by re-enabling " "passphrases and entering its passphrase.") else: msg = _("Your current ElectrumSV wallet can only be used with " "an empty passphrase. You must create a separate " "wallet with the install wizard for other passphrases " "as each one generates a new set of addresses.") msg += "\n\n" + _("Are you sure you want to proceed?") if not self.question(msg, title=title): return invoke_client('toggle_passphrase', unpair_after=currently_enabled) def set_pin(): invoke_client('set_pin', remove=False) def clear_pin(): invoke_client('set_pin', remove=True) def wipe_device(): accounts = window._wallet.get_accounts_for_keystore(keystore) if sum(sum(account.get_balance()) for account in accounts): title = _("Confirm Device Wipe") msg = _("Are you SURE you want to wipe the device?\n" "Your wallet still has bitcoins in it!") if not self.question( msg, title=title, icon=QMessageBox.Critical): return invoke_client('wipe_device', unpair_after=True) def slider_moved(): mins = timeout_slider.sliderPosition() timeout_minutes.setText(_("%2d minutes") % mins) def slider_released(): config.set_session_timeout(timeout_slider.sliderPosition() * 60) # Information tab info_tab = QWidget() info_layout = QVBoxLayout(info_tab) info_glayout = QGridLayout() info_glayout.setColumnStretch(2, 1) device_label = QLabel() pin_set_label = QLabel() passphrases_label = QLabel() version_label = QLabel() device_id_label = QLabel() bl_hash_label = QLabel() bl_hash_label.setWordWrap(True) language_label = QLabel() initialized_label = QLabel() rows = [ (_("Device Label"), device_label), (_("PIN set"), pin_set_label), (_("Passphrases"), passphrases_label), (_("Firmware Version"), version_label), (_("Device ID"), device_id_label), (_("Bootloader Hash"), bl_hash_label), (_("Language"), language_label), (_("Initialized"), initialized_label), ] for row_num, (label, widget) in enumerate(rows): info_glayout.addWidget(QLabel(label), row_num, 0) info_glayout.addWidget(widget, row_num, 1) info_layout.addLayout(info_glayout) # Settings tab settings_tab = QWidget() settings_layout = QVBoxLayout(settings_tab) settings_glayout = QGridLayout() # Settings tab - Label label_msg = QLabel( _("Name this {}. If you have multiple devices " "their labels help distinguish them.").format(plugin.device)) label_msg.setWordWrap(True) label_label = QLabel(_("Device Label")) label_edit = QLineEdit() label_edit.setMinimumWidth(150) label_edit.setMaxLength(plugin.MAX_LABEL_LEN) label_apply = QPushButton(_("Apply")) label_apply.clicked.connect(rename) label_edit.textChanged.connect(set_label_enabled) settings_glayout.addWidget(label_label, 0, 0) settings_glayout.addWidget(label_edit, 0, 1, 1, 2) settings_glayout.addWidget(label_apply, 0, 3) settings_glayout.addWidget(label_msg, 1, 1, 1, -1) # Settings tab - PIN pin_label = QLabel(_("PIN Protection")) pin_button = QPushButton() pin_button.clicked.connect(set_pin) settings_glayout.addWidget(pin_label, 2, 0) settings_glayout.addWidget(pin_button, 2, 1) pin_msg = QLabel( _("PIN protection is strongly recommended. " "A PIN is your only protection against someone " "stealing your bitcoins if they obtain physical " "access to your {}.").format(plugin.device)) pin_msg.setWordWrap(True) pin_msg.setStyleSheet("color: red") settings_glayout.addWidget(pin_msg, 3, 1, 1, -1) # Settings tab - Session Timeout timeout_label = QLabel(_("Session Timeout")) timeout_minutes = QLabel() timeout_slider = QSlider(Qt.Horizontal) timeout_slider.setRange(1, 60) timeout_slider.setSingleStep(1) timeout_slider.setTickInterval(5) timeout_slider.setTickPosition(QSlider.TicksBelow) timeout_slider.setTracking(True) timeout_msg = QLabel( _("Clear the session after the specified period " "of inactivity. Once a session has timed out, " "your PIN and passphrase (if enabled) must be " "re-entered to use the device.")) timeout_msg.setWordWrap(True) timeout_slider.setSliderPosition(config.get_session_timeout() // 60) slider_moved() timeout_slider.valueChanged.connect(slider_moved) timeout_slider.sliderReleased.connect(slider_released) settings_glayout.addWidget(timeout_label, 6, 0) settings_glayout.addWidget(timeout_slider, 6, 1, 1, 3) settings_glayout.addWidget(timeout_minutes, 6, 4) settings_glayout.addWidget(timeout_msg, 7, 1, 1, -1) settings_layout.addLayout(settings_glayout) settings_layout.addStretch(1) # Advanced tab advanced_tab = QWidget() advanced_layout = QVBoxLayout(advanced_tab) advanced_glayout = QGridLayout() # Advanced tab - clear PIN clear_pin_button = QPushButton(_("Disable PIN")) clear_pin_button.clicked.connect(clear_pin) clear_pin_warning = QLabel( _("If you disable your PIN, anyone with physical access to your " "{} device can spend your bitcoins.").format(plugin.device)) clear_pin_warning.setWordWrap(True) clear_pin_warning.setStyleSheet("color: red") advanced_glayout.addWidget(clear_pin_button, 0, 2) advanced_glayout.addWidget(clear_pin_warning, 1, 0, 1, 5) # Advanced tab - toggle passphrase protection passphrase_button = QPushButton() passphrase_button.clicked.connect(toggle_passphrase) passphrase_msg = WWLabel(PASSPHRASE_HELP) passphrase_warning = WWLabel(PASSPHRASE_NOT_PIN) passphrase_warning.setStyleSheet("color: red") advanced_glayout.addWidget(passphrase_button, 3, 2) advanced_glayout.addWidget(passphrase_msg, 4, 0, 1, 5) advanced_glayout.addWidget(passphrase_warning, 5, 0, 1, 5) # Advanced tab - wipe device wipe_device_button = QPushButton(_("Wipe Device")) wipe_device_button.clicked.connect(wipe_device) wipe_device_msg = QLabel( _("Wipe the device, removing all data from it. The firmware " "is left unchanged.")) wipe_device_msg.setWordWrap(True) wipe_device_warning = QLabel( _("Only wipe a device if you have the recovery seed written down " "and the device wallet(s) are empty, otherwise the bitcoins " "will be lost forever.")) wipe_device_warning.setWordWrap(True) wipe_device_warning.setStyleSheet("color: red") advanced_glayout.addWidget(wipe_device_button, 6, 2) advanced_glayout.addWidget(wipe_device_msg, 7, 0, 1, 5) advanced_glayout.addWidget(wipe_device_warning, 8, 0, 1, 5) advanced_layout.addLayout(advanced_glayout) advanced_layout.addStretch(1) tabs = QTabWidget(self) tabs.addTab(info_tab, _("Information")) tabs.addTab(settings_tab, _("Settings")) tabs.addTab(advanced_tab, _("Advanced")) dialog_vbox = QVBoxLayout(self) dialog_vbox.addWidget(tabs) dialog_vbox.addLayout(Buttons(CloseButton(self))) # Update information invoke_client(None)
def initUI(self): """ Set up the user interface, signals & slots For better understaning, I made some shortcuts for variables, which is the instance of the QtWidgets classes. List of shortcuts(made): *btn - QPushButton; *lbl - QLabel; *slr - QSlider; *lyt - Q_lyt; *ctrl - ctrl; """ self.widget = QWidget(self) self.setCentralWidget(self.widget) #video widget self.videoframe = QFrame() self.palette = self.videoframe.palette() self.palette.setColor(QtGui.QPalette.Window, QtGui.QColor(0, 0, 0)) self.videoframe.setPalette(self.palette) self.videoframe.setAutoFillBackground(True) #time value self.timevalue = QDateTimeEdit() self.timevalue.setDisplayFormat('hh:mm:ss') self.timevalue.setReadOnly(True) self.timevalue.setFixedSize(80, 30) #position slider self.position_slr = QSlider(QtCore.Qt.Horizontal, self) self.position_slr.setToolTip("Position") self.position_slr.setMaximum(1000) self.position_slr.sliderMoved.connect(self.set_position) #play button self.play_btn = QPushButton() self.play_btn.setProperty("onplay", True) self.play_btn.setObjectName("play") self.play_btn.clicked.connect(self.play_pause) #stop button self.stop_btn = QPushButton() self.stop_btn.setObjectName('stop') self.stop_btn.clicked.connect(self.stop) #analyse button self.analyse_btn = QPushButton('Analyse') self.analyse_btn.setObjectName('analyse') self.analyse_btn.setFixedSize(70, 28) self.analyse_btn.clicked.connect(self.start_analyse) self.analyse_window = Analyse(self) self.analyse_window.off() self.analyse_btn.setEnabled(False) self.on_analyse = False self.details_btn = QPushButton('Details') self.details_btn.setVisible(False) self.details_btn.setObjectName('details') self.details_btn.setFixedSize(70, 28) self.details_btn.clicked.connect(self.show_details) self.details_wd = pictureViewer() self.details_wd.close() self.threadpool = QtCore.QThreadPool() self.threadpool.setMaxThreadCount(1) worker = loadModules(self) self.threadpool.start(worker) self.path_input = pathLineEdit(self) self.path_input.setObjectName('path') self.folder_btn = QPushButton() self.folder_btn.setObjectName('folder') self.folder_btn.clicked.connect( lambda x: self.select_folder(foldername='')) self.fileslist_lbl = QLabel('Playlist:') self.fileslist_lbl.setObjectName('lbl') self.fileslist_lbl.setIndent(12) self.fileslist = QListWidget() self.fileslist.itemClicked.connect(self.select_file) self.warnings_lbl = QLabel('Warnings time:') self.warnings_lbl.setObjectName('lbl') self.warnings_lbl.setIndent(12) self.warningslist = QListWidget() #volume slider self.volume_slr = QSlider(QtCore.Qt.Horizontal, self) self.volume_slr.setMaximum(100) self.volume_slr.setValue(self.mediaplayer.audio_get_volume()) self.volume_slr.setToolTip("Volume") self.volume_slr.valueChanged.connect(self.set_volume) #setting up layouts folder_lyt = QHBoxLayout() folder_lyt.addWidget(self.path_input) folder_lyt.addWidget(self.folder_btn) leftside_lyt = QVBoxLayout() leftside_lyt.setContentsMargins(0, 10, 0, 0) leftside_lyt.addSpacing(6) leftside_lyt.addWidget(self.fileslist_lbl) leftside_lyt.addWidget(self.fileslist) analyse_btns = QHBoxLayout() analyse_btns.addWidget(self.details_btn) analyse_btns.addWidget(self.analyse_btn) leftside_lyt.addLayout(analyse_btns) leftside_lyt.addWidget(self.warnings_lbl) leftside_lyt.addWidget(self.warningslist) leftside_lyt.addLayout(folder_lyt) leftside_lyt.addSpacing(6) self.leftside_bg = QWidget() self.leftside_bg.setObjectName("leftside_bg") self.leftside_bg.setLayout(leftside_lyt) ctrl_lyt = QHBoxLayout() ctrl_lyt.addSpacing(20) ctrl_lyt.addWidget(self.play_btn) ctrl_lyt.setSpacing(0) ctrl_lyt.addWidget(self.stop_btn) ctrl_lyt.addStretch(1) ctrl_lyt.addWidget(self.volume_slr) ctrl_panel_lyt = QVBoxLayout() ctrl_panel_lyt.setContentsMargins(60, 12, 60, 12) ctrl_panel_lyt.addWidget(self.timevalue, 0, QtCore.Qt.AlignLeft) ctrl_panel_lyt.addWidget(self.position_slr) ctrl_panel_lyt.addLayout(ctrl_lyt) rightside_lyt = QVBoxLayout() rightside_lyt.addWidget(self.videoframe) rightside_lyt.addLayout(ctrl_panel_lyt) main_lyt = QHBoxLayout() main_lyt.setSpacing(0) main_lyt.setContentsMargins(0, 0, 0, 0) main_lyt.addWidget(self.leftside_bg) main_lyt.addLayout(rightside_lyt, 60) self.widget.setLayout(main_lyt) self.timer = QtCore.QTimer(self) self.timer.setInterval(200) self.timer.timeout.connect(self.updateUI) #creates connection to db self.db = db_api.create_connection( os.path.join(os.getcwd(), 'db', 'data.db'))
class Player(QWidget): fullScreenChanged = pyqtSignal(bool) def __init__(self, playlist, parent=None): super(Player, self).__init__(parent) _globals['quit']=False self.colorDialog = None self.trackInfo = "" self.statusInfo = "" self.duration = 0 self.height0 = None self.player = QMediaPlayer() self.playlist = QMediaPlaylist() self.player.setPlaylist(self.playlist) self.player.durationChanged.connect(self.durationChanged) self.player.positionChanged.connect(self.positionChanged) self.player.metaDataChanged.connect(self.metaDataChanged) self.playlist.currentIndexChanged.connect(self.playlistPositionChanged) self.player.mediaStatusChanged.connect(self.statusChanged) self.player.bufferStatusChanged.connect(self.bufferingProgress) self.player.videoAvailableChanged.connect(self.videoAvailableChanged) self.player.error.connect(self.displayErrorMessage) self.videoWidget = VideoWidget() self.player.setVideoOutput(self.videoWidget) self.playlistModel = PlaylistModel() self.playlistModel.setPlaylist(self.playlist) self.playlistView = QListView() self.playlistView.setModel(self.playlistModel) self.playlistView.setCurrentIndex( self.playlistModel.index(self.playlist.currentIndex(), 0)) self.playlistView.activated.connect(self.jump) self.slider = QSlider(Qt.Horizontal) self.slider.setRange(0, self.player.duration() / 1000) self.labelDuration = QLabel() self.slider.sliderMoved.connect(self.seek) self.labelHistogram = QLabel() self.labelHistogram.setText("Histogram:") self.histogram = HistogramWidget() histogramLayout = QHBoxLayout() histogramLayout.addWidget(self.labelHistogram) histogramLayout.addWidget(self.histogram, 1) self.probe = QVideoProbe() self.probe.videoFrameProbed.connect(self.histogram.processFrame) self.probe.setSource(self.player) openButton = QPushButton("Open", clicked=self.open) controls = PlayerControls() controls.setState(self.player.state()) controls.setVolume(self.player.volume()) controls.setMuted(controls.isMuted()) controls.play.connect(self.player.play) controls.pause.connect(self.player.pause) controls.stop.connect(self.player.stop) controls.next.connect(self.playlist.next) controls.previous.connect(self.previousClicked) controls.changeVolume.connect(self.player.setVolume) controls.changeMuting.connect(self.player.setMuted) controls.changeRate.connect(self.player.setPlaybackRate) controls.stop.connect(self.videoWidget.update) self.player.stateChanged.connect(controls.setState) self.player.volumeChanged.connect(controls.setVolume) self.player.mutedChanged.connect(controls.setMuted) self.fullScreenButton = QPushButton("FullScreen") self.fullScreenButton.setCheckable(True) self.colorButton = QPushButton("Color Options...") self.colorButton.setEnabled(False) self.colorButton.clicked.connect(self.showColorDialog) displayLayout = QHBoxLayout() displayLayout.addWidget(self.videoWidget) # displayLayout.addWidget(self.playlistView) controlLayout = QHBoxLayout() controlLayout.setContentsMargins(0, 0, 0, 0) controlLayout.addWidget(openButton) controlLayout.addStretch(1) controlLayout.addWidget(controls) controlLayout.addStretch(1) controlLayout.addWidget(self.fullScreenButton) controlLayout.addWidget(self.colorButton) layout = QVBoxLayout() layout.addLayout(displayLayout,1) hLayout = QHBoxLayout() hLayout.addWidget(self.slider) hLayout.addWidget(self.labelDuration) self.videoWidget.setMinimumHeight(300) layout.addLayout(hLayout) layout.addLayout(controlLayout) # layout.addLayout(histogramLayout) self.setLayout(layout) if not self.player.isAvailable(): QMessageBox.warning(self, "Service not available", "The QMediaPlayer object does not have a valid service.\n" "Please check the media service plugins are installed.") controls.setEnabled(False) self.playlistView.setEnabled(False) openButton.setEnabled(False) self.colorButton.setEnabled(False) self.fullScreenButton.setEnabled(False) self.metaDataChanged() self.addToPlaylist(playlist) def closeEvent(self,e): print('close') _globals['quit'] = True self.player.stop() def open(self): fileNames, _ = QFileDialog.getOpenFileNames(self, "Open Files") self.addToPlaylist(fileNames) def addToPlaylist(self, fileNames): for name in fileNames: fileInfo = QFileInfo(name) if fileInfo.exists(): url = QUrl.fromLocalFile(fileInfo.absoluteFilePath()) if fileInfo.suffix().lower() == 'm3u': self.playlist.load(url) else: self.playlist.addMedia(QMediaContent(url)) else: url = QUrl(name) if url.isValid(): self.playlist.addMedia(QMediaContent(url)) def durationChanged(self, duration): duration /= 1000 self.duration = duration self.slider.setMaximum(duration) def positionChanged(self, progress): progress /= 1000 if not self.slider.isSliderDown(): self.slider.setValue(progress) self.updateDurationInfo(progress) def metaDataChanged(self): if self.player.isMetaDataAvailable(): self.setTrackInfo("%s - %s" % ( self.player.metaData(QMediaMetaData.AlbumArtist), self.player.metaData(QMediaMetaData.Title))) def previousClicked(self): # Go to the previous track if we are within the first 5 seconds of # playback. Otherwise, seek to the beginning. if self.player.position() <= 5000: self.playlist.previous() else: self.player.setPosition(0) def jump(self, index): if index.isValid(): self.playlist.setCurrentIndex(index.row()) self.player.play() def playlistPositionChanged(self, position): self.playlistView.setCurrentIndex( self.playlistModel.index(position, 0)) def seek(self, seconds): self.player.setPosition(seconds * 1000) def statusChanged(self, status): self.handleCursor(status) if status == QMediaPlayer.LoadingMedia: self.setStatusInfo("Loading...") elif status == QMediaPlayer.StalledMedia: self.setStatusInfo("Media Stalled") elif status == QMediaPlayer.EndOfMedia: QApplication.alert(self) elif status == QMediaPlayer.InvalidMedia: self.displayErrorMessage() else: self.setStatusInfo("") def handleCursor(self, status): if status in (QMediaPlayer.LoadingMedia, QMediaPlayer.BufferingMedia, QMediaPlayer.StalledMedia): self.setCursor(Qt.BusyCursor) else: self.unsetCursor() def bufferingProgress(self, progress): self.setStatusInfo("Buffering %d%" % progress) def videoAvailableChanged(self, available): if available: self.fullScreenButton.clicked.connect( self.videoWidget.setFullScreen) self.videoWidget.fullScreenChanged.connect( self.fullScreenButton.setChecked) if self.fullScreenButton.isChecked(): self.videoWidget.setFullScreen(True) else: self.fullScreenButton.clicked.disconnect( self.videoWidget.setFullScreen) self.videoWidget.fullScreenChanged.disconnect( self.fullScreenButton.setChecked) self.videoWidget.setFullScreen(False) self.colorButton.setEnabled(available) def setTrackInfo(self, info): self.trackInfo = info if self.statusInfo != "": self.setWindowTitle("%s | %s" % (self.trackInfo, self.statusInfo)) else: self.setWindowTitle(self.trackInfo) def setStatusInfo(self, info): self.statusInfo = info if self.statusInfo != "": self.setWindowTitle("%s | %s" % (self.trackInfo, self.statusInfo)) else: self.setWindowTitle(self.trackInfo) def displayErrorMessage(self): self.setStatusInfo(self.player.errorString()) def updateDurationInfo(self, currentInfo): duration = self.duration if currentInfo or duration: currentTime = QTime((currentInfo/3600)%60, (currentInfo/60)%60, currentInfo%60, (currentInfo*1000)%1000) totalTime = QTime((duration/3600)%60, (duration/60)%60, duration%60, (duration*1000)%1000); format = 'hh:mm:ss' if duration > 3600 else 'mm:ss' tStr = currentTime.toString(format) + " / " + totalTime.toString(format) else: tStr = "" self.labelDuration.setText(tStr) def showColorDialog(self): if self.colorDialog is None: brightnessSlider = QSlider(Qt.Horizontal) brightnessSlider.setRange(-100, 100) brightnessSlider.setValue(self.videoWidget.brightness()) brightnessSlider.sliderMoved.connect( self.videoWidget.setBrightness) self.videoWidget.brightnessChanged.connect( brightnessSlider.setValue) contrastSlider = QSlider(Qt.Horizontal) contrastSlider.setRange(-100, 100) contrastSlider.setValue(self.videoWidget.contrast()) contrastSlider.sliderMoved.connect(self.videoWidget.setContrast) self.videoWidget.contrastChanged.connect(contrastSlider.setValue) hueSlider = QSlider(Qt.Horizontal) hueSlider.setRange(-100, 100) hueSlider.setValue(self.videoWidget.hue()) hueSlider.sliderMoved.connect(self.videoWidget.setHue) self.videoWidget.hueChanged.connect(hueSlider.setValue) saturationSlider = QSlider(Qt.Horizontal) saturationSlider.setRange(-100, 100) saturationSlider.setValue(self.videoWidget.saturation()) saturationSlider.sliderMoved.connect( self.videoWidget.setSaturation) self.videoWidget.saturationChanged.connect( saturationSlider.setValue) layout = QFormLayout() layout.addRow("Brightness", brightnessSlider) layout.addRow("Contrast", contrastSlider) layout.addRow("Hue", hueSlider) layout.addRow("Saturation", saturationSlider) button = QPushButton("Close") layout.addRow(button) self.colorDialog = QDialog(self) self.colorDialog.setWindowTitle("Color Options") self.colorDialog.setLayout(layout) button.clicked.connect(self.colorDialog.close) self.colorDialog.show()
class PreferencesDialogBase(QDialog): def __init__(self, parent, app, **kwargs): flags = Qt.CustomizeWindowHint | Qt.WindowTitleHint | Qt.WindowSystemMenuHint super().__init__(parent, flags, **kwargs) self.app = app self._setupUi() self.filterHardnessSlider.valueChanged['int'].connect( self.filterHardnessLabel.setNum) self.buttonBox.clicked.connect(self.buttonClicked) self.buttonBox.accepted.connect(self.accept) self.buttonBox.rejected.connect(self.reject) def _setupScanTypeBox(self, labels): self.scanTypeHLayout = QHBoxLayout() self.scanTypeLabel = QLabel(self) self.scanTypeLabel.setText(tr("Scan Type:")) self.scanTypeLabel.setMinimumSize(QSize(100, 0)) self.scanTypeLabel.setMaximumSize(QSize(100, 16777215)) self.scanTypeHLayout.addWidget(self.scanTypeLabel) self.scanTypeComboBox = QComboBox(self) for label in labels: self.scanTypeComboBox.addItem(label) self.scanTypeHLayout.addWidget(self.scanTypeComboBox) self.widgetsVLayout.addLayout(self.scanTypeHLayout) def _setupFilterHardnessBox(self): self.filterHardnessHLayout = QHBoxLayout() self.filterHardnessLabel = QLabel(self) self.filterHardnessLabel.setText(tr("Filter Hardness:")) self.filterHardnessLabel.setMinimumSize(QSize(0, 0)) self.filterHardnessHLayout.addWidget(self.filterHardnessLabel) self.filterHardnessVLayout = QVBoxLayout() self.filterHardnessVLayout.setSpacing(0) self.filterHardnessHLayoutSub1 = QHBoxLayout() self.filterHardnessHLayoutSub1.setSpacing(12) self.filterHardnessSlider = QSlider(self) sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth( self.filterHardnessSlider.sizePolicy().hasHeightForWidth()) self.filterHardnessSlider.setSizePolicy(sizePolicy) self.filterHardnessSlider.setMinimum(1) self.filterHardnessSlider.setMaximum(100) self.filterHardnessSlider.setTracking(True) self.filterHardnessSlider.setOrientation(Qt.Horizontal) self.filterHardnessHLayoutSub1.addWidget(self.filterHardnessSlider) self.filterHardnessLabel = QLabel(self) self.filterHardnessLabel.setText("100") self.filterHardnessLabel.setMinimumSize(QSize(21, 0)) self.filterHardnessHLayoutSub1.addWidget(self.filterHardnessLabel) self.filterHardnessVLayout.addLayout(self.filterHardnessHLayoutSub1) self.filterHardnessHLayoutSub2 = QHBoxLayout() self.filterHardnessHLayoutSub2.setContentsMargins(-1, 0, -1, -1) self.moreResultsLabel = QLabel(self) self.moreResultsLabel.setText(tr("More Results")) self.filterHardnessHLayoutSub2.addWidget(self.moreResultsLabel) spacerItem = QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum) self.filterHardnessHLayoutSub2.addItem(spacerItem) self.fewerResultsLabel = QLabel(self) self.fewerResultsLabel.setText(tr("Fewer Results")) self.filterHardnessHLayoutSub2.addWidget(self.fewerResultsLabel) self.filterHardnessVLayout.addLayout(self.filterHardnessHLayoutSub2) self.filterHardnessHLayout.addLayout(self.filterHardnessVLayout) def _setupBottomPart(self): # The bottom part of the pref panel is always the same in all editions. self.fontSizeLabel = QLabel(tr("Font size:")) self.fontSizeSpinBox = QSpinBox() self.fontSizeSpinBox.setMinimum(5) self.widgetsVLayout.addLayout( horizontalWrap([self.fontSizeLabel, self.fontSizeSpinBox, None])) self.languageLabel = QLabel(tr("Language:"), self) self.languageComboBox = QComboBox(self) for lang in SUPPORTED_LANGUAGES: self.languageComboBox.addItem(LANGNAMES[lang]) self.widgetsVLayout.addLayout( horizontalWrap([self.languageLabel, self.languageComboBox, None])) self.copyMoveLabel = QLabel(self) self.copyMoveLabel.setText(tr("Copy and Move:")) self.widgetsVLayout.addWidget(self.copyMoveLabel) self.copyMoveDestinationComboBox = QComboBox(self) self.copyMoveDestinationComboBox.addItem(tr("Right in destination")) self.copyMoveDestinationComboBox.addItem(tr("Recreate relative path")) self.copyMoveDestinationComboBox.addItem(tr("Recreate absolute path")) self.widgetsVLayout.addWidget(self.copyMoveDestinationComboBox) self.customCommandLabel = QLabel(self) self.customCommandLabel.setText( tr("Custom Command (arguments: %d for dupe, %r for ref):")) self.widgetsVLayout.addWidget(self.customCommandLabel) self.customCommandEdit = QLineEdit(self) self.widgetsVLayout.addWidget(self.customCommandEdit) def _setupAddCheckbox(self, name, label, parent=None): if parent is None: parent = self cb = QCheckBox(parent) cb.setText(label) setattr(self, name, cb) def _setupPreferenceWidgets(self): # Edition-specific pass def _setupUi(self): self.setWindowTitle(tr("Preferences")) self.resize(304, 263) self.setSizeGripEnabled(False) self.setModal(True) self.mainVLayout = QVBoxLayout(self) self.widgetsVLayout = QVBoxLayout() self._setupPreferenceWidgets() self.mainVLayout.addLayout(self.widgetsVLayout) self.buttonBox = QDialogButtonBox(self) self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel | QDialogButtonBox.Ok | QDialogButtonBox.RestoreDefaults) self.mainVLayout.addWidget(self.buttonBox) if (not ISOSX) and (not ISLINUX): self.mainVLayout.removeWidget(self.ignoreHardlinkMatches) self.ignoreHardlinkMatches.setHidden(True) def _load(self, prefs, setchecked): # Edition-specific pass def _save(self, prefs, ischecked): # Edition-specific pass def load(self, prefs=None): if prefs is None: prefs = self.app.prefs self.filterHardnessSlider.setValue(prefs.filter_hardness) self.filterHardnessLabel.setNum(prefs.filter_hardness) setchecked = lambda cb, b: cb.setCheckState(Qt.Checked if b else Qt.Unchecked) setchecked(self.mixFileKindBox, prefs.mix_file_kind) setchecked(self.useRegexpBox, prefs.use_regexp) setchecked(self.removeEmptyFoldersBox, prefs.remove_empty_folders) setchecked(self.ignoreHardlinkMatches, prefs.ignore_hardlink_matches) setchecked(self.debugModeBox, prefs.debug_mode) self.copyMoveDestinationComboBox.setCurrentIndex( prefs.destination_type) self.customCommandEdit.setText(prefs.custom_command) self.fontSizeSpinBox.setValue(prefs.tableFontSize) try: langindex = SUPPORTED_LANGUAGES.index(self.app.prefs.language) except ValueError: langindex = 0 self.languageComboBox.setCurrentIndex(langindex) self._load(prefs, setchecked) def save(self): prefs = self.app.prefs prefs.filter_hardness = self.filterHardnessSlider.value() ischecked = lambda cb: cb.checkState() == Qt.Checked prefs.mix_file_kind = ischecked(self.mixFileKindBox) prefs.use_regexp = ischecked(self.useRegexpBox) prefs.remove_empty_folders = ischecked(self.removeEmptyFoldersBox) prefs.ignore_hardlink_matches = ischecked(self.ignoreHardlinkMatches) prefs.debug_mode = ischecked(self.debugModeBox) prefs.destination_type = self.copyMoveDestinationComboBox.currentIndex( ) prefs.custom_command = str(self.customCommandEdit.text()) prefs.tableFontSize = self.fontSizeSpinBox.value() lang = SUPPORTED_LANGUAGES[self.languageComboBox.currentIndex()] oldlang = self.app.prefs.language if oldlang not in SUPPORTED_LANGUAGES: oldlang = 'en' if lang != oldlang: QMessageBox.information( self, "", tr("dupeGuru has to restart for language changes to take effect." )) self.app.prefs.language = lang self._save(prefs, ischecked) #--- Events def buttonClicked(self, button): role = self.buttonBox.buttonRole(button) if role == QDialogButtonBox.ResetRole: self.resetToDefaults()
def initUI(self): #menu statusbar self.statusBar().showMessage('Ready') menubar = self.menuBar() fileMenu = menubar.addMenu('File') editMenu = menubar.addMenu('Edit') impMenu = QMenu('Import', self) impAct = QAction('Import mail', self) impMenu.addAction(impAct) newAct = QAction('New', self) fileMenu.addAction(newAct) fileMenu.addMenu(impMenu) #toolbar exitAct = QAction(QIcon('exit.png'), 'Exit', self) exitAct.setShortcut('Ctrl+Q') exitAct.triggered.connect(qApp.quit) self.toolbar = self.addToolBar('Exit') self.toolbar.addAction(exitAct) self.setMinimumSize(QSize(180, 180)) self.setWindowTitle("PyQt") self.setWindowIcon(QIcon('exit.png')) # Create Main Widget mainwidget = QWidget() self.setCentralWidget(mainwidget) grid = QGridLayout() mainwidget.setLayout(grid) # Buttons b1 = QPushButton('QUIT', self) b2 = QPushButton('button with long text', self) grid.addWidget(b1, 1, 1) grid.addWidget(b2, 2, 1) # Enter fields t1 = QLabel('text input') t2 = QLabel('multiline input') t1f = QLineEdit() t2f = QTextEdit() t2f.resize(50, 250) grid.addWidget(t1, 3, 0) grid.addWidget(t1f, 3, 1) grid.addWidget(t2, 4, 0) grid.addWidget(t2f, 4, 1) #Listbox l1t = QLabel('list') l1 = QListWidget(self) l1.resize(50, 50) for i in range(6): l1.addItem('alt%s' % (i + 1)) grid.addWidget(l1t, 5, 0) grid.addWidget(l1, 5, 1) #Combo c1t = QLabel('combo') c1 = QComboBox(self) for i in range(6): c1.addItem('alt%s' % (i + 1)) grid.addWidget(c1t, 6, 0) grid.addWidget(c1, 6, 1) #Radio groupBox = QGroupBox('Radio') layout = QHBoxLayout() self.b1 = QRadioButton("One") self.b1.setChecked(True) self.b1.toggled.connect(lambda: self.btnstate(self.b1)) layout.addWidget(self.b1) self.b2 = QRadioButton("Two") self.b2.toggled.connect(lambda: self.btnstate(self.b2)) layout.addWidget(self.b2) groupBox.setLayout(layout) grid.addWidget(groupBox, 7, 1) #Checkbox cb = QCheckBox('toggle', self) grid.addWidget(cb, 8, 0) #Slider s1t = QLabel('slider') s1 = QSlider(Qt.Horizontal) grid.addWidget(s1t, 9, 0) grid.addWidget(s1, 9, 1) #progress p1t = QLabel('progress') p1 = QProgressBar(self) p1.setValue(40) grid.addWidget(p1t, 10, 0) grid.addWidget(p1, 10, 1)
class PlayerControls(QWidget): play = pyqtSignal() pause = pyqtSignal() stop = pyqtSignal() next = pyqtSignal() previous = pyqtSignal() changeVolume = pyqtSignal(int) changeMuting = pyqtSignal(bool) changeRate = pyqtSignal(float) def __init__(self, parent=None): super(PlayerControls, self).__init__(parent) self.playerState = QMediaPlayer.StoppedState self.playerMuted = False self.playButton = QToolButton(clicked=self.playClicked) self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay)) self.stopButton = QToolButton(clicked=self.stop) self.stopButton.setIcon(self.style().standardIcon(QStyle.SP_MediaStop)) self.stopButton.setEnabled(False) self.nextButton = QToolButton(clicked=self.next) self.nextButton.setIcon( self.style().standardIcon(QStyle.SP_MediaSkipForward)) self.previousButton = QToolButton(clicked=self.previous) self.previousButton.setIcon( self.style().standardIcon(QStyle.SP_MediaSkipBackward)) self.muteButton = QToolButton(clicked=self.muteClicked) self.muteButton.setIcon( self.style().standardIcon(QStyle.SP_MediaVolume)) self.volumeSlider = QSlider(Qt.Horizontal, sliderMoved=self.changeVolume) self.volumeSlider.setRange(0, 100) self.rateBox = QComboBox(activated=self.updateRate) self.rateBox.addItem("0.5x", 0.5) self.rateBox.addItem("1.0x", 1.0) self.rateBox.addItem("2.0x", 2.0) self.rateBox.setCurrentIndex(1) layout = QHBoxLayout() layout.setContentsMargins(0, 0, 0, 0) layout.addWidget(self.stopButton) layout.addWidget(self.previousButton) layout.addWidget(self.playButton) layout.addWidget(self.nextButton) layout.addWidget(self.muteButton) layout.addWidget(self.volumeSlider) layout.addWidget(self.rateBox) self.setLayout(layout) def state(self): return self.playerState def setState(self,state): if state != self.playerState: self.playerState = state if state == QMediaPlayer.StoppedState: self.stopButton.setEnabled(False) self.playButton.setIcon( self.style().standardIcon(QStyle.SP_MediaPlay)) if not _globals['quit']: self.playClicked() elif state == QMediaPlayer.PlayingState: self.stopButton.setEnabled(True) self.playButton.setIcon( self.style().standardIcon(QStyle.SP_MediaPause)) elif state == QMediaPlayer.PausedState: self.stopButton.setEnabled(True) self.playButton.setIcon( self.style().standardIcon(QStyle.SP_MediaPlay)) def volume(self): return self.volumeSlider.value() def setVolume(self, volume): self.volumeSlider.setValue(volume) def isMuted(self): return self.playerMuted def setMuted(self, muted): if muted != self.playerMuted: self.playerMuted = muted self.muteButton.setIcon( self.style().standardIcon( QStyle.SP_MediaVolumeMuted if muted else QStyle.SP_MediaVolume)) def playClicked(self): if self.playerState in (QMediaPlayer.StoppedState, QMediaPlayer.PausedState): self.play.emit() elif self.playerState == QMediaPlayer.PlayingState: self.pause.emit() def muteClicked(self): self.changeMuting.emit(not self.playerMuted) def playbackRate(self): return self.rateBox.itemData(self.rateBox.currentIndex()) def setPlaybackRate(self, rate): for i in range(self.rateBox.count()): if qFuzzyCompare(rate, self.rateBox.itemData(i)): self.rateBox.setCurrentIndex(i) return self.rateBox.addItem("%dx" % rate, rate) self.rateBox.setCurrentIndex(self.rateBox.count() - 1) def updateRate(self): self.changeRate.emit(self.playbackRate())
def block1(self): self.block1_group_box = QGroupBox("Theme and utility") self.block1_group_box.setToolTip(self.tooltips["colors_and_opacity"]) b1 = QPushButton() b1.setText("Background color") b1.setObjectName("background_color_button") b1.clicked.connect(self.on_click) self.background_color_line = QLineEdit() self.background_color_line.setReadOnly(True) self.background_color_prew = QLabel() self.background_color_prew.setMinimumSize(20, 1) b2 = QPushButton() b2.setText("Accent color") b2.setObjectName("accent_color_button") b2.clicked.connect(self.on_click) self.accent_color_line = QLineEdit() self.accent_color_line.setReadOnly(True) self.accent_color_prew = QLabel() self.accent_color_prew.setMinimumSize(20, 1) # opacity l1 = QLabel() l1.setText("Opacity") self.opacity_slider = QSlider(Qt.Horizontal) self.opacity_slider.setRange(10, 100) self.opacity_slider.valueChanged.connect(self.update_opacity) self.opacity_label = QLabel() self.opacity_label.setText("10.0") # Frame delay l2 = QLabel() l2.setText("Window invisibility time") l2.setToolTip(self.tooltips["frame_delay"]) self.frame_delay_selector = QDoubleSpinBox() self.frame_delay_selector.setMinimum(0.0) self.frame_delay_selector.setSingleStep(0.1) self.frame_delay_selector.setToolTip(self.tooltips["frame_delay"]) hbox1 = QHBoxLayout() hbox2 = QHBoxLayout() hbox3 = QHBoxLayout() hbox4 = QHBoxLayout() vbox = QVBoxLayout() hbox1.addWidget(b1) hbox1.addStretch() hbox1.addWidget(self.background_color_prew) hbox1.addWidget(self.background_color_line) hbox2.addWidget(b2) hbox2.addStretch() hbox2.addWidget(self.accent_color_prew) hbox2.addWidget(self.accent_color_line) hbox3.addWidget(l1) hbox3.addWidget(self.opacity_label) hbox3.addWidget(self.opacity_slider) hbox4.addWidget(l2) hbox4.addStretch() hbox4.addWidget(self.frame_delay_selector) vbox.addLayout(hbox1) vbox.addLayout(hbox2) vbox.addLayout(hbox3) vbox.addLayout(hbox4) self.block1_group_box.setLayout(vbox)
class Qshot_settings(QMainWindow): # pyqtsignal has a bug so I have to write these here oppcity_emitter = pyqtSignal(float) background_color_emitter = pyqtSignal(str) accent_color_emitter = pyqtSignal(str) update_frame_emitter = pyqtSignal() hide_frame_emitter = pyqtSignal(bool) def __init__(self, cfg_path, default_cfg_path, statics_path): super().__init__() self.cfg_path = cfg_path self.default_cfg_path = default_cfg_path self.tooltips_path = os.path.join(statics_path, "texts", "tooltips.yaml") self.about_path = os.path.join(statics_path, "texts", "about.txt") self.icon_path = os.path.join(statics_path, "icons", "Qs.ico") self.is_settings_started = False # start frame and options def start_settings(self): """starts settings window this is not in the constructor because it slows startup of the main frame and if there is an error on the cfg file I want settings popup after main frames popup """ self.is_settings_started = True # once frame started I don't want to recreate it again (this variable used in the Quickshot.py) self.init_variables() self.set_static_variables() self.set_default_cfg() self.init_ui() cfg_status = self.read_cfg_file() if (cfg_status): self.variable_to_ui() def update_settings_ui(self): """refreshes the settings frame without recreating ui elements""" cfg_status = self.read_cfg_file() if (cfg_status): self.variable_to_ui() self.show() def init_ui(self): """inits ui""" self.setWindowTitle("Qshot Settings") self.setWindowIcon(QtGui.QIcon(self.icon_path)) self.menu_bar() self.block1() self.block2() self.block3() self.block4() self.block5() self.setup_ui() self.show() def init_variables(self): """inits class variables""" self.ss_extensions_list = [".png", ".jpg"] self.png_compression_level_list = [ "1", "2", "3", "4", "5", "6", "7", "8", "9" ] # read options and assign to local variable (file -> ui) def read_cfg_file(self): """Reads cfg file and makes assignment to local variables shows error popup if cfg file has errors """ try: # read cfg file with open(self.cfg_path, "r") as file: cfg = yaml.safe_load(file) # quickshot_frame # theme self.background_color = cfg["quickshot_frame"]["theme"][ "background_color"] self.accent_color = cfg["quickshot_frame"]["theme"]["accent_color"] self.opacity = cfg["quickshot_frame"]["theme"]["opacity"] # hotkeys self.ss_hotkey = cfg["quickshot_frame"]["hotkeys"]["ss_hotkey"] self.hide_hotkey = cfg["quickshot_frame"]["hotkeys"]["hide_hotkey"] # utilities self.frame_delay = cfg["quickshot_frame"]["utilities"][ "frame_delay"] # ss ss_handler # naming self.save_path = os.path.normpath( cfg["ss_handler"]["naming"]["save_path"]) # convert to path self.create_root_file = cfg["ss_handler"]["naming"][ "create_root_file"] self.before_ss_name = cfg["ss_handler"]["naming"]["before_ss_name"] self.after_ss_name = cfg["ss_handler"]["naming"]["after_ss_name"] self.before_number = cfg["ss_handler"]["naming"]["before_number"] self.after_number = cfg["ss_handler"]["naming"]["after_number"] self.date_formatting = cfg["ss_handler"]["naming"][ "date_formatting"] self.use_system_local_date_naming = cfg["ss_handler"]["naming"][ "use_system_local_date_naming"] # ss_options self.ss_extension = cfg["ss_handler"]["ss_options"]["ss_extension"] self.png_compression_level = cfg["ss_handler"]["ss_options"][ "png_compression_level"] self.default_screen = cfg["ss_handler"]["ss_options"][ "default_screen"] self.save_clipboard = cfg["ss_handler"]["ss_options"][ "save_clipboard"] return True except Exception as e: print(e) self.show_alert_popup( "There is a problem with cfg file please reset settings and restart Quickshot" ) return False def variable_to_ui(self): """assigns local variables to ui""" try: # theme and utilities self.opacity_slider.setSliderPosition(int(self.opacity * 100)) self.background_color_line.setText(self.background_color) self.background_color_prew.setStyleSheet( "background-color: {0};".format(self.background_color)) self.accent_color_line.setText(self.accent_color) self.accent_color_prew.setStyleSheet( "background-color: {0};".format(self.accent_color)) # hotkeys self.ss_key_line.setText(self.ss_hotkey) self.hide_key.setText(self.hide_hotkey) # set the frame delay self.frame_delay_selector.setValue(self.frame_delay) # path and naming self.save_path_line.setText(self.save_path) self.root_file_line.setText(self.create_root_file) self.before_ss_name_line.setText(self.before_ss_name) self.after_ss_name_line.setText(self.after_ss_name) self.before_number_line.setText(self.before_number) self.after_number_line.setText(self.after_number) self.date_formatting_line.setText(self.date_formatting) if (self.use_system_local_date_naming): self.local_date_naming_checkbox.setChecked(True) else: self.local_date_naming_checkbox.setChecked(False) # ss options extension_index = self.extension_combobox.findText( self.ss_extension, QtCore.Qt.MatchFixedString) self.extension_combobox.setCurrentIndex(extension_index) compression_level_index = self.png_compression_combobox.findText( str(self.png_compression_level), QtCore.Qt.MatchFixedString) self.png_compression_combobox.setCurrentIndex( compression_level_index) # if all_screens_checkbox is checked disable the default_screen_selector if (self.default_screen == 0): self.all_screens_checkbox.setChecked(True) self.default_screen_selector.setDisabled(True) else: self.all_screens_checkbox.setChecked(False) self.default_screen_selector.setDisabled(False) self.default_screen_selector.setValue(self.default_screen) if (self.save_clipboard): self.save_clipboard_checkbox.setChecked(True) else: self.save_clipboard_checkbox.setChecked(False) except Exception as e: print(e) self.show_alert_popup( "There is a problem with cfg file please reset settings and restart Quickshot" ) # get options from ui and write them to file (ui -> file) def ui_to_variable(self): """assign selected settings to new_cfg variable""" try: # colors and opacity self.new_cfg["quickshot_frame"]["theme"][ "background_color"] = self.background_color_line.text() self.new_cfg["quickshot_frame"]["theme"][ "accent_color"] = self.accent_color_line.text() self.new_cfg["quickshot_frame"]["theme"][ "opacity"] = self.opacity_slider.value() / 100 # hotkeys self.new_cfg["quickshot_frame"]["hotkeys"][ "ss_hotkey"] = self.ss_key_line.text() self.new_cfg["quickshot_frame"]["hotkeys"][ "hide_hotkey"] = self.hide_key.text() # set the frame delay self.new_cfg["quickshot_frame"]["utilities"][ "frame_delay"] = self.frame_delay_selector.value() # path and naming self.new_cfg["ss_handler"]["naming"][ "save_path"] = self.save_path_line.text() self.new_cfg["ss_handler"]["naming"][ "create_root_file"] = self.root_file_line.text() self.new_cfg["ss_handler"]["naming"][ "before_ss_name"] = self.before_ss_name_line.text() self.new_cfg["ss_handler"]["naming"][ "after_ss_name"] = self.after_ss_name_line.text() self.new_cfg["ss_handler"]["naming"][ "before_number"] = self.before_number_line.text() self.new_cfg["ss_handler"]["naming"][ "after_number"] = self.after_number_line.text() self.new_cfg["ss_handler"]["naming"][ "date_formatting"] = self.date_formatting_line.text() if (self.local_date_naming_checkbox.isChecked()): self.new_cfg["ss_handler"]["naming"][ "use_system_local_date_naming"] = 1 else: self.new_cfg["ss_handler"]["naming"][ "use_system_local_date_naming"] = 0 # ss options self.new_cfg["ss_handler"]["ss_options"][ "ss_extension"] = self.extension_combobox.currentText() self.new_cfg["ss_handler"]["ss_options"][ "png_compression_level"] = int( self.png_compression_combobox.currentText()) if (self.all_screens_checkbox.isChecked()): self.new_cfg["ss_handler"]["ss_options"]["default_screen"] = 0 else: self.new_cfg["ss_handler"]["ss_options"][ "default_screen"] = self.default_screen_selector.value() if (self.save_clipboard_checkbox.isChecked()): self.new_cfg["ss_handler"]["ss_options"]["save_clipboard"] = 1 else: self.new_cfg["ss_handler"]["ss_options"]["save_clipboard"] = 0 return True except Exception as e: print(e) self.show_alert_popup( "There is a problem with saving values please check the values or reset settings" ) return False def write_cfg_file(self, cfg): try: with open(self.cfg_path, "w") as file: yaml.dump(cfg, file, indent=4) return True except Exception as e: print(e) self.show_alert_popup( "There is a problem with saving values please check the values or reset settings" ) return False def set_default_cfg(self): """Reads default_cfg_file and sets default_cfg and new_cfg""" try: # read default_cfg_file with open(self.default_cfg_path, "r") as file: self.default_cfg = yaml.safe_load(file) # new_cfg is just a copy of default_cfg but has to be deep copy, it is going to be changed according to ui self.new_cfg = copy.deepcopy(self.default_cfg) except Exception as e: print(e) self.show_alert_popup( "There is a problem with installation, please reinstall the application." ) self.close() def set_static_variables(self): """Reads and sets set_static_variables""" try: with open(self.tooltips_path, "r") as file: self.tooltips = yaml.safe_load(file) with open(self.about_path, "r") as file: self.about_text = file.read() except Exception as e: print(e) self.show_alert_popup( "There is a problem with installation, please reinstall the application." ) self.close() # ui elements def setup_ui(self): """sets up ui by assigning elements to layouts""" self.grid = QGridLayout() self.main_grid = QGridLayout() # top grid self.grid.addWidget(self.block1_group_box, 0, 0) self.grid.addWidget(self.block2_group_box, 0, 1) self.grid.addWidget(self.block3_group_box, 1, 0) self.grid.addWidget(self.block4_group_box, 1, 1) # bottom grid self.main_grid.addLayout(self.grid, 0, 0) self.main_grid.addLayout(self.bottom_layout, 1, 0) # central widget is required when using Q mainwindow self.central_widget = QtWidgets.QWidget(self) self.central_widget.setLayout(self.main_grid) self.setCentralWidget(self.central_widget) def block1(self): self.block1_group_box = QGroupBox("Theme and utility") self.block1_group_box.setToolTip(self.tooltips["colors_and_opacity"]) b1 = QPushButton() b1.setText("Background color") b1.setObjectName("background_color_button") b1.clicked.connect(self.on_click) self.background_color_line = QLineEdit() self.background_color_line.setReadOnly(True) self.background_color_prew = QLabel() self.background_color_prew.setMinimumSize(20, 1) b2 = QPushButton() b2.setText("Accent color") b2.setObjectName("accent_color_button") b2.clicked.connect(self.on_click) self.accent_color_line = QLineEdit() self.accent_color_line.setReadOnly(True) self.accent_color_prew = QLabel() self.accent_color_prew.setMinimumSize(20, 1) # opacity l1 = QLabel() l1.setText("Opacity") self.opacity_slider = QSlider(Qt.Horizontal) self.opacity_slider.setRange(10, 100) self.opacity_slider.valueChanged.connect(self.update_opacity) self.opacity_label = QLabel() self.opacity_label.setText("10.0") # Frame delay l2 = QLabel() l2.setText("Window invisibility time") l2.setToolTip(self.tooltips["frame_delay"]) self.frame_delay_selector = QDoubleSpinBox() self.frame_delay_selector.setMinimum(0.0) self.frame_delay_selector.setSingleStep(0.1) self.frame_delay_selector.setToolTip(self.tooltips["frame_delay"]) hbox1 = QHBoxLayout() hbox2 = QHBoxLayout() hbox3 = QHBoxLayout() hbox4 = QHBoxLayout() vbox = QVBoxLayout() hbox1.addWidget(b1) hbox1.addStretch() hbox1.addWidget(self.background_color_prew) hbox1.addWidget(self.background_color_line) hbox2.addWidget(b2) hbox2.addStretch() hbox2.addWidget(self.accent_color_prew) hbox2.addWidget(self.accent_color_line) hbox3.addWidget(l1) hbox3.addWidget(self.opacity_label) hbox3.addWidget(self.opacity_slider) hbox4.addWidget(l2) hbox4.addStretch() hbox4.addWidget(self.frame_delay_selector) vbox.addLayout(hbox1) vbox.addLayout(hbox2) vbox.addLayout(hbox3) vbox.addLayout(hbox4) self.block1_group_box.setLayout(vbox) def block2(self): self.block2_group_box = QGroupBox("Hotkeys") self.block2_group_box.setToolTip(self.tooltips["hotkeys"]) l1 = QLabel() l1.setText("Screenshot key") self.ss_key_line = QLineEdit() self.ss_key_line.setText("") l2 = QLabel() l2.setText("Hide key") self.hide_key = QLineEdit() self.hide_key.setText("") hbox1 = QHBoxLayout() hbox2 = QHBoxLayout() vbox = QVBoxLayout() hbox1.addWidget(l1) hbox1.addStretch() hbox1.addWidget(self.ss_key_line) hbox2.addWidget(l2) hbox2.addStretch() hbox2.addWidget(self.hide_key) vbox.addLayout(hbox1) vbox.addLayout(hbox2) self.block2_group_box.setLayout(vbox) def block3(self): self.block3_group_box = QGroupBox("Path and naming") # Save Path b1 = QPushButton() b1.setText("Chose save folder") b1.setObjectName("save_path_button") b1.clicked.connect(self.on_click) self.save_path_line = QLineEdit() self.save_path_line.setToolTip(self.tooltips["save_path"]) # Root file l2 = QLabel() l2.setText("Root file") l2.setToolTip(self.tooltips["root_file"]) self.root_file_line = QLineEdit() self.root_file_line.setToolTip(self.tooltips["root_file"]) # Text before ss name l3 = QLabel() l3.setText("Text before ss name") l3.setToolTip(self.tooltips["text_before_ss-text_after_ss"]) self.before_ss_name_line = QLineEdit() self.before_ss_name_line.setToolTip( self.tooltips["text_before_ss-text_after_ss"]) # Text after ss name l4 = QLabel() l4.setText("Text after ss name") l4.setToolTip(self.tooltips["text_before_ss-text_after_ss"]) self.after_ss_name_line = QLineEdit() self.after_ss_name_line.setToolTip( self.tooltips["text_before_ss-text_after_ss"]) # Text before ss number l5 = QLabel() l5.setText("Text before ss number") l5.setToolTip( self.tooltips["text_before_ss_number-text_after_ss_number"]) self.before_number_line = QLineEdit() self.before_number_line.setToolTip( self.tooltips["text_before_ss_number-text_after_ss_number"]) # Text after ss number l6 = QLabel() l6.setText("Text after ss number") l6.setToolTip( self.tooltips["text_before_ss_number-text_after_ss_number"]) self.after_number_line = QLineEdit() self.after_number_line.setToolTip( self.tooltips["text_before_ss_number-text_after_ss_number"]) # Date formatting l7 = QLabel() l7.setText("Date formatting") l7.setToolTip(self.tooltips["date_formatting"]) self.date_formatting_line = QLineEdit() self.date_formatting_line.setToolTip(self.tooltips["date_formatting"]) # Use local date naming l8 = QLabel() l8.setText("Use local date naming") l8.setToolTip(self.tooltips["Use_local_date_naming"]) self.local_date_naming_checkbox = QCheckBox() self.local_date_naming_checkbox.setToolTip( self.tooltips["Use_local_date_naming"]) hbox1 = QHBoxLayout() hbox2 = QHBoxLayout() hbox3 = QHBoxLayout() hbox4 = QHBoxLayout() hbox5 = QHBoxLayout() hbox6 = QHBoxLayout() hbox7 = QHBoxLayout() hbox8 = QHBoxLayout() vbox = QVBoxLayout() hbox1.addWidget(b1) hbox1.addStretch() hbox1.addWidget(self.save_path_line) hbox2.addWidget(l2) hbox2.addStretch() hbox2.addWidget(self.root_file_line) hbox3.addWidget(l3) hbox3.addStretch() hbox3.addWidget(self.before_ss_name_line) hbox4.addWidget(l4) hbox4.addStretch() hbox4.addWidget(self.after_ss_name_line) hbox5.addWidget(l5) hbox5.addStretch() hbox5.addWidget(self.before_number_line) hbox6.addWidget(l6) hbox6.addStretch() hbox6.addWidget(self.after_number_line) hbox7.addWidget(l7) hbox7.addStretch() hbox7.addWidget(self.date_formatting_line) hbox8.addWidget(l8) hbox8.addStretch() hbox8.addWidget(self.local_date_naming_checkbox) vbox.addLayout(hbox1) vbox.addLayout(hbox2) vbox.addLayout(hbox3) vbox.addLayout(hbox4) vbox.addLayout(hbox5) vbox.addLayout(hbox6) vbox.addLayout(hbox7) vbox.addLayout(hbox8) self.block3_group_box.setLayout(vbox) def block4(self): self.block4_group_box = QGroupBox("Screenshot options") # extension l1 = QLabel() l1.setText("Extension") l1.setToolTip(self.tooltips["extension"]) self.extension_combobox = QComboBox() self.extension_combobox.addItems(self.ss_extensions_list) self.extension_combobox.setToolTip(self.tooltips["extension"]) # png compression level l2 = QLabel() l2.setText("png compression level") l2.setToolTip(self.tooltips["png_compression_level"]) self.png_compression_combobox = QComboBox() self.png_compression_combobox.addItems(self.png_compression_level_list) self.png_compression_combobox.setToolTip( self.tooltips["png_compression_level"]) # Default screen l4 = QLabel() l4.setText("Default screen") l4.setToolTip(self.tooltips["default_screen"]) l5 = QLabel() l5.setText("All") l5.setToolTip(self.tooltips["default_screen"]) self.all_screens_checkbox = QCheckBox() self.all_screens_checkbox.setObjectName("all_screens_checkbox") self.all_screens_checkbox.clicked.connect(self.on_click) self.all_screens_checkbox.setToolTip(self.tooltips["default_screen"]) self.default_screen_selector = QSpinBox() self.default_screen_selector.setMinimum(1) self.default_screen_selector.setToolTip( self.tooltips["default_screen"]) # save clipboard l6 = QLabel() l6.setText("Copy ss to clipboard") l6.setToolTip(self.tooltips["save_clipboard"]) self.save_clipboard_checkbox = QCheckBox() self.save_clipboard_checkbox.setToolTip( self.tooltips["save_clipboard"]) hbox1 = QHBoxLayout() hbox2 = QHBoxLayout() hbox3 = QHBoxLayout() hbox4 = QHBoxLayout() hbox5 = QHBoxLayout() vbox = QVBoxLayout() hbox1.addWidget(l1) hbox1.addStretch() hbox1.addWidget(self.extension_combobox) hbox2.addWidget(l2) hbox2.addStretch() hbox2.addWidget(self.png_compression_combobox) hbox4.addWidget(l4) hbox4.addStretch() hbox4.addWidget(l5) hbox4.addWidget(self.all_screens_checkbox) hbox4.addWidget(self.default_screen_selector) hbox5.addWidget(l6) hbox5.addStretch() hbox5.addWidget(self.save_clipboard_checkbox) vbox.addLayout(hbox1) vbox.addLayout(hbox2) vbox.addLayout(hbox3) vbox.addLayout(hbox4) vbox.addLayout(hbox5) self.block4_group_box.setLayout(vbox) def block5(self): self.bottom_layout = QHBoxLayout() l1 = QLabel() l1.setText("Hover over sections for tips") l1.setFont(QFont('Arial', 8, weight=QtGui.QFont.Bold)) b1 = QPushButton() b1.setText("Save changes") b1.setObjectName("save_changes_button") b1.clicked.connect(self.on_click) b2 = QPushButton() b2.setText("Reset to default") b2.setObjectName("reset_button") b2.clicked.connect(self.on_click) self.bottom_layout.addWidget(l1) self.bottom_layout.addStretch() self.bottom_layout.addWidget(b2) self.bottom_layout.addWidget(b1) def menu_bar(self): """adds menu bar and actions under it""" # menu items self.bar = self.menuBar() self.file_menu = self.bar.addMenu("File") self.help_menu = self.bar.addMenu("Help") # File actions self.save_action = QAction("Save", self) self.save_action.setShortcut("Ctrl+S") self.save_action.setObjectName("save") self.save_action.triggered.connect(self.on_click) self.exit_action = QAction("Exit", self) self.exit_action.setShortcut("Ctrl+Q") self.exit_action.setObjectName("exit") self.exit_action.triggered.connect(self.on_click) self.file_menu.addAction(self.save_action) self.file_menu.addAction(self.exit_action) # Help actions self.about_action = QAction("About", self) self.about_action.setObjectName("about") self.about_action.triggered.connect(self.on_click) self.help_menu.addAction(self.about_action) # popups def show_alert_popup(self, alert_str): """shows alert popup with given message""" self.hide_frame_emitter.emit( True) # hide the ss frame when showing popup msg = QMessageBox() msg.setIcon(QMessageBox.Critical) msg.setWindowIcon(QtGui.QIcon(self.icon_path)) msg.setWindowTitle("Alert") msg.setText(alert_str) msg.exec() self.hide_frame_emitter.emit(False) def show_success_popup(self, success_str): """shows success popup with given message""" self.hide_frame_emitter.emit( True) # hide the ss frame when showing popup msg = QMessageBox() msg.setIcon(QMessageBox.Information) msg.setWindowIcon(QtGui.QIcon(self.icon_path)) msg.setWindowTitle("Success") msg.setText(success_str) msg.exec() self.hide_frame_emitter.emit(False) def show_about_popup(self): """shows about popup""" self.hide_frame_emitter.emit( True) # hide the ss frame when showing popup msg = QMessageBox() msg.setIcon(QMessageBox.Information) msg.setWindowIcon(QtGui.QIcon(self.icon_path)) msg.setWindowTitle("About") msg.setTextFormat(Qt.RichText) msg.setText(self.about_text) msg.exec() self.hide_frame_emitter.emit(False) # preview functions def activate_preview(self): """activates preview mode""" self.background_color_emitter.emit(self.background_color_line.text()) self.accent_color_emitter.emit(self.accent_color_line.text()) self.oppcity_emitter.emit(self.opacity_slider.value() / 100) # self.setWindowOpacity(self.opacity_slider.value()/100) def revert_preview(self): """reverts to default values""" self.background_color_emitter.emit(None) self.accent_color_emitter.emit(None) self.oppcity_emitter.emit(-1) # self.setWindowOpacity(1) # event listeners def closeEvent(self, event): """actions before close""" self.revert_preview() def update_opacity(self, value): """updates opacity value on frame and emits signal to main frame to update opacity""" self.opacity_label.setText(str(value / 100)) self.oppcity_emitter.emit(value / 100) def on_click(self): """on click function for listeners""" sender = self.sender() # buttons if (sender.objectName() == "background_color_button"): """writes background color code to lineedit, shows color on color label, emits color change signal to main frame""" self.hide_frame_emitter.emit( True) # hide the ss frame when opening color picker color = QColorDialog.getColor() self.hide_frame_emitter.emit(False) if (color.isValid()): self.background_color_line.setText(color.name()) self.background_color_prew.setStyleSheet( "background-color: {0};".format(color.name())) self.background_color_emitter.emit(color.name()) elif (sender.objectName() == "accent_color_button"): """writes accent color code to lineedit, shows color on color label, emits color change signal to main frame""" self.hide_frame_emitter.emit( True) # hide the ss frame when opening color picker color = QColorDialog.getColor() self.hide_frame_emitter.emit(False) if (color.isValid()): self.accent_color_line.setText(color.name()) self.accent_color_prew.setStyleSheet( "background-color: {0};".format(color.name())) self.accent_color_emitter.emit(color.name()) elif (sender.objectName() == "save_path_button"): """opens a folder dialog for save path location""" save_path = str( QFileDialog.getExistingDirectory(self, "Select Directory")) if (save_path): self.save_path_line.setText(save_path) elif (sender.objectName() == "reset_button"): """writes default values to cfg file, reads cfg file and updates ui, emits signal to main frame for updating, shows success popup (write_cfg_file has error popup so I don't need here)""" write_status = self.write_cfg_file(self.default_cfg) if (write_status): self.read_cfg_file() self.variable_to_ui() self.update_frame_emitter.emit() self.show_success_popup("Settings reset to default") elif (sender.objectName() == "save_changes_button" or sender.objectName() == "save"): """takes settings from ui writes them to cfg file, emits signal to main frame for updating, shows success popup (write_cfg_file has error popup so I don't need here)""" variable_status = self.ui_to_variable() if (variable_status): write_status = self.write_cfg_file(self.new_cfg) if (write_status): self.update_frame_emitter.emit() self.show_success_popup("Settings saved") # menu items elif (sender.objectName() == "exit"): self.close() elif (sender.objectName() == "about"): self.show_about_popup() # checkboxes elif (sender.objectName() == "all_screens_checkbox"): # if all_screens_checkbox is checked disable the default_screen_selector if (self.all_screens_checkbox.isChecked()): self.default_screen_selector.setDisabled(True) else: self.default_screen_selector.setDisabled(False)
def multisig_dialog(self, run_next): cw = CosignWidget(2, 2) m_edit = QSlider(Qt.Horizontal, self) n_edit = QSlider(Qt.Horizontal, self) n_edit.setMinimum(2) n_edit.setMaximum(15) m_edit.setMinimum(1) m_edit.setMaximum(2) n_edit.setValue(2) m_edit.setValue(2) n_label = QLabel() m_label = QLabel() grid = QGridLayout() grid.addWidget(n_label, 0, 0) grid.addWidget(n_edit, 0, 1) grid.addWidget(m_label, 1, 0) grid.addWidget(m_edit, 1, 1) def on_m(m): m_label.setText(_('Require {0} signatures').format(m)) cw.set_m(m) backup_warning_label.setVisible(cw.m != cw.n) def on_n(n): n_label.setText(_('From {0} cosigners').format(n)) cw.set_n(n) m_edit.setMaximum(n) backup_warning_label.setVisible(cw.m != cw.n) n_edit.valueChanged.connect(on_n) m_edit.valueChanged.connect(on_m) vbox = QVBoxLayout() vbox.addWidget(cw) vbox.addWidget(WWLabel(_("Choose the number of signatures needed to unlock funds in your wallet:"))) vbox.addLayout(grid) vbox.addSpacing(2 * char_width_in_lineedit()) backup_warning_label = WWLabel(_("Warning: to be able to restore a multisig wallet, " "you should include the master public key for each cosigner " "in all of your backups.")) vbox.addWidget(backup_warning_label) on_n(2) on_m(2) self.exec_layout(vbox, _("Multi-Signature Wallet")) m = int(m_edit.value()) n = int(n_edit.value()) return (m, n)
class StartWindow(QMainWindow): def __init__(self): self.inital_completed = False self.threadpool = QThreadPool() self.lock = Lock() self.video_stream = None root = Tk() root.withdraw() self.root_dir = askdirectory( initialdir="/", title="Select root directory containing all cage folders") if self.root_dir is (): raise AssertionError else: self.database_local_dir = 'database/homecage_database.sqlite' self.F = None super().__init__() self.widget_main = QWidget() self.play_speed = 0 self.image_label = QLabel() self.image_label.resize(1280, 720) self.radio_group = [ QRadioButton('Unlabeled'), QRadioButton('Labeled') ] self.components_left = [ QLabel("Cage"), QComboBox(), QLabel("Animal"), QComboBox(), QLabel("Date"), QLabel("From"), QCalendarWidget(), QLabel("Till"), QCalendarWidget(), QLabel("Video List || Double click :)"), QListWidget() ] self.components_right_low = [ QPushButton('Play(space)'), QPushButton('Speed(q): %d' % self.play_speed), QPushButton('Next Frame (d)'), QPushButton('Previous Frame (a)'), QPushButton('Start Labeling (s)'), QPushButton('Clean all labels') ] for i in range(len(self.components_right_low)): self.components_right_low[i].setDisabled(True) self.Playing_Flag = False self.layout_main = QGridLayout() self.layout_left = QVBoxLayout() self.layout_radio = QHBoxLayout() self.layout_right_high = QVBoxLayout() self.layout_right_low = QHBoxLayout() self.widget_main.setLayout(self.layout_main) for component in self.components_left: self.layout_left.addWidget(component) for component in self.components_right_low: self.layout_right_low.addWidget(component) for radio in self.radio_group: self.layout_radio.addWidget(radio) self.slider = QSlider(Qt.Horizontal) self.slider.setTickPosition(QSlider.TicksBothSides) self.slider.setTickInterval(10) self.slider.setSingleStep(1) self.slider.setValue(0) self.radio_group[0].setChecked(True) self.layout_right_high.addWidget(self.image_label) self.layout_right_high.addWidget(self.slider) self.components_left[6].setMaximumDate(datetime.datetime.now()) self.components_left[8].setMaximumDate(datetime.datetime.now()) self.min_date = datetime.datetime.now() self.max_date = datetime.datetime.now() self.layout_left.addLayout(self.layout_radio) self.layout_main.addLayout(self.layout_left, 0, 0, 4, 1) self.layout_main.addLayout(self.layout_right_high, 0, 2, 4, 4) self.layout_main.addLayout(self.layout_right_low, 4, 2, 5, 5) self.setCentralWidget(self.widget_main) self.overlay = Overlay(self.centralWidget()) self.overlay.show() self.show() self.thread_get_cages() self.components_left[1].currentIndexChanged.connect( self.on_select_cage) self.components_left[3].currentIndexChanged.connect( self.on_select_animal) self.components_left[6].selectionChanged.connect( self.on_select_date_min) self.components_left[8].selectionChanged.connect( self.on_select_date_max) self.components_left[10].itemDoubleClicked.connect( self.on_select_video) self.components_left[10].setSelectionMode( QListWidget.SingleSelection) self.slider.sliderMoved.connect(self.on_slider) self.slider.sliderReleased.connect(self.on_slider_release) self.components_right_low[0].clicked.connect(self.on_play) self.components_right_low[1].clicked.connect(self.on_speed) self.components_right_low[2].clicked.connect(self.on_next_frame) self.components_right_low[3].clicked.connect( self.on_previous_frame) self.components_right_low[4].clicked.connect(self.on_labeling) self.components_right_low[5].clicked.connect(self.on_clean_all) for i in range(len(self.radio_group)): self.radio_group[i].clicked.connect( lambda: self.on_radio(self.radio_group[i])) self.init_image = cv2.imread(os.path.join("pic", "init.jpg")) self.init_image = cv2.cvtColor(self.init_image, cv2.COLOR_BGR2RGB) self.init_image = cv2.resize(self.init_image, (1280, 720)) self.th = imageThread() self.th.changePixmap.connect(self.update_image) self.th.start() self.th.frames_queue.put(self.init_image) self.animal = "" self.index = 0 self.inital_completed = True self.start_frame = 0 self.end_frame = 0 self.event_dict = { 0: "Knock Down", 1: "Attemp", 2: "Success", 3: "Successful Lick", 4: "Discard this event" } self.current_video_list_all = [] self.current_video_list_unlabeled = [] self.current_video_list_labeled = [] self.video_path = None self.slider_queue = Queue() self.thread_update_slider() self.thread_update_database() def keyPressEvent(self, event): global FLAG_EVENT_START global FLAG_PLAYING self.components_right_low[0].setFocus() key_id = (event.key() & 0xFF) + 32 if self.video_stream is not None: if FLAG_EVENT_START and key_id in range(80, 90): event_id = key_id - 80 self.on_saving(event_id) if key_id == ord(" "): self.on_play() elif key_id == ord("q"): self.on_speed() elif key_id == ord("d"): if not FLAG_PLAYING: self.on_next_frame() elif key_id == ord('a'): if not FLAG_PLAYING: self.on_previous_frame() elif key_id == ord('s'): self.on_labeling() self.components_right_low[4].setDisabled(True) @pyqtSlot(QImage) def update_image(self, qImg): self.image_label.setPixmap(QPixmap.fromImage(qImg)) def on_radio(self, r): if self.inital_completed: self.overlay.show() self.thread_update_list_radio() def on_play(self): self.components_right_low[0].setFocus() global FLAG_PLAYING FLAG_PLAYING = not FLAG_PLAYING if FLAG_PLAYING: self.components_right_low[0].setText("Pulse(space)") self.thread_play_video() self.components_right_low[2].setDisabled(True) self.components_right_low[3].setDisabled(True) else: self.components_right_low[0].setText("Play(space)") self.components_right_low[2].setDisabled(False) self.components_right_low[3].setDisabled(False) def on_speed(self): self.components_right_low[0].setFocus() self.play_speed = (self.play_speed + 1) % 3 self.components_right_low[1].setText("Speed(q): %d" % self.play_speed) def on_slider(self): global FLAG_PLAYING FLAG_PLAYING = False self.slider_queue.empty() if self.video_stream is not None: if self.slider.value() % 20 == 0: self.video_stream.set(cv2.CAP_PROP_POS_FRAMES, self.slider.value()) grab, frame = self.video_stream.read() self.th.frames_queue.put(frame) def on_slider_release(self): self.components_right_low[0].setFocus() global FLAG_PLAYING FLAG_PLAYING = True self.components_right_low[0].setText("Pulse(space)") self.thread_play_video() def on_select_cage(self): if self.inital_completed: self.overlay.show() self.thread_get_animals() def on_select_animal(self): if self.inital_completed: self.overlay.show() self.animal = self.components_left[3].currentText() self.thread_get_videos() def on_select_date_min(self): if self.inital_completed: self.overlay.show() self.thread_update_list_min() def on_select_date_max(self): if self.inital_completed: self.overlay.show() self.thread_update_list_max() def on_select_video(self): global FLAG_PLAYING if self.inital_completed: self.overlay.show() FLAG_PLAYING = False self.slider_queue.empty() self.slider_queue.put(1) self.video_path = self.components_left[10].selectedItems()[0].text() self.thread_load_video() self.components_right_low[2].setDisabled(False) self.components_right_low[3].setDisabled(False) def on_next_frame(self): self.components_right_low[0].setFocus() current_pos = self.slider.value() + 1 if current_pos >= self.total_frames - 1: current_pos = 0 self.slider_queue.put(current_pos) self.video_stream.set(cv2.CAP_PROP_POS_FRAMES, current_pos) grab, frame = self.video_stream.read() self.th.frames_queue.put(frame) def on_previous_frame(self): self.components_right_low[0].setFocus() current_pos = self.slider.value() - 1 if current_pos <= 1: current_pos = self.total_frames - 2 self.slider_queue.put(current_pos) self.video_stream.set(cv2.CAP_PROP_POS_FRAMES, current_pos) grab, frame = self.video_stream.read() self.th.frames_queue.put(frame) def on_clean_all(self): buttonReply = QMessageBox.question( self, 'PyQt5 message', "Do you want to delete all the labels in this video?", QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel, QMessageBox.Cancel) if buttonReply == QMessageBox.Yes: sql = sqlHandler(self.database_local_dir) sql.delete(self.video_path) sql.close() self._update_video_list() self.components_right_low[0].setFocus() def on_labeling(self): global FLAG_EVENT_START self.start_frame = self.slider.value() items = self.components_left[10].selectedItems() if len(items) > 0: FLAG_EVENT_START = True else: FLAG_EVENT_START = False self.components_right_low[4].setDisabled(True) self.components_right_low[0].setFocus() def on_saving(self, event_id): sql = sqlHandler(self.database_local_dir) global FLAG_EVENT_START self.end_frame = self.slider.value() if event_id in self.event_dict.keys(): sql.insert(self.video_path, self.start_frame, self.end_frame, self.event_dict[event_id]) FLAG_EVENT_START = False sql.close() self.components_right_low[4].setDisabled(False) ################################################################################################################### def thread_get_cages(self): # Pass the function to execute worker = Worker( self._get_cages ) # Any other args, kwargs are passed to the run function worker.signals.result.connect(self._set_cages) worker.signals.finished.connect(self.thread_complete) worker.signals.progress.connect(self.progress_fn) # Execute self.threadpool.start(worker) def _get_cages(self, progress_callback): if self.F is None: self.F = FileStructure(self.root_dir) return self.F.get_cages() def _set_cages(self, cages): self.components_left[1].clear() self.components_left[3].clear() self.components_left[10].clear() for cage in cages: self.components_left[1].addItem(cage) ################################################################################################################ def thread_get_animals(self): # Pass the function to execute worker = Worker( self._get_animals ) # Any other args, kwargs are passed to the run function worker.signals.result.connect(self._set_animals) worker.signals.finished.connect(self.thread_complete) worker.signals.progress.connect(self.progress_fn) # Execute self.threadpool.start(worker) def _get_animals(self, progress_callback): return self.F.get_animals(self.components_left[1].currentText()) def _set_animals(self, animals): self.components_left[3].clear() self.components_left[10].clear() for animal in animals: self.components_left[3].addItem(animal) ################################################################################################################# def thread_get_videos(self): # Pass the function to execute worker = Worker( self._get_videos ) # Any other args, kwargs are passed to the run function worker.signals.result.connect(self._set_videos) worker.signals.finished.connect(self.thread_complete) worker.signals.progress.connect(self.progress_fn) # Execute self.threadpool.start(worker) def _get_videos(self, progress_callback): while self.animal == '': self.animal = self.components_left[3].currentText() time.sleep(0.5) self.F.get_video_list(self.animal) def _set_videos(self, animals): self._update_video_list() ################################################################################################################# def thread_load_video(self): # Pass the function to execute worker = Worker( self._load_video ) # Any other args, kwargs are passed to the run function worker.signals.result.connect(self._set_frame) worker.signals.finished.connect(self.thread_complete) worker.signals.progress.connect(self.progress_fn) # Execute self.threadpool.start(worker) def _load_video(self, progress_callback): shutil.rmtree('temp', ignore_errors=True) os.mkdir('temp') shutil.copyfile( self.video_path, os.path.join('temp', os.path.basename(self.video_path))) if self.video_stream is not None: self.video_stream.release() self.video_stream = cv2.VideoCapture( os.path.join('temp', os.path.basename(self.video_path))) self.total_frames = self.video_stream.get(cv2.CAP_PROP_FRAME_COUNT) self.slider.setRange(0, self.total_frames) return None def _set_frame(self, _): if not self.video_stream.isOpened(): root = Tk() root.withdraw() messagebox.showerror("Error", "Broken video!") self.video_stream = None else: grab, frame = self.video_stream.read() self.th.frames_queue.put(frame) for i in range(len(self.components_right_low)): self.components_right_low[i].setDisabled(False) self.components_right_low[0].setFocus() ################################################################################################################# def thread_play_video(self): # Pass the function to execute worker = Worker( self._play_video ) # Any other args, kwargs are passed to the run function worker.signals.result.connect(self._close_video) worker.signals.finished.connect(self.thread_complete) worker.signals.progress.connect(self.progress_fn) # Execute self.threadpool.start(worker) def showdialog(self): msg = QMessageBox() msg.setIcon(QMessageBox.Information) msg.setText("Are you sure there is no event in this video?") msg.setWindowTitle("No events confirmation") msg.setStandardButtons(QMessageBox.Yes | QMessageBox.Cancel) retval = msg.exec_() msg.close() msg.destroy() return retval def _play_video(self, progress_callback): total_frames = self.video_stream.get(cv2.CAP_PROP_FRAME_COUNT) global FLAG_PLAYING while FLAG_PLAYING: current_pos = self.slider.value() + 1 self.slider_queue.put(current_pos) time.sleep([0.05, 0.02, 0][self.play_speed]) if current_pos < total_frames - 1: grab, frame = self.video_stream.read() if grab and frame is not None: self.th.frames_queue.put(frame) else: FLAG_PLAYING = False self.components_right_low[2].setDisabled(False) self.components_right_low[3].setDisabled(False) break def _close_video(self, _): total_frames = self.video_stream.get(cv2.CAP_PROP_FRAME_COUNT) self.components_right_low[0].setText("Play(space)") if self.slider.value() > total_frames - 2: sql = sqlHandler(self.database_local_dir) flag = sql.is_labeled(self.video_path) sql.close() buttonReply = True if not flag: buttonReply = self.showdialog() if buttonReply == QMessageBox.Yes: sql = sqlHandler(self.database_local_dir) sql.insert(self.video_path, 0, 0, 'empty') sql.close() buttonReply = True else: buttonReply = False if (self.video_path not in self.current_video_list_labeled) and buttonReply: self.current_video_list_labeled.append(self.video_path) self.current_video_list_unlabeled = [ item for item in self.current_video_list_all if item not in self.current_video_list_labeled ] self.components_left[10].clear() if self.radio_group[0].isChecked(): if len(self.current_video_list_unlabeled) > 0: self.components_left[10].addItems( self.current_video_list_unlabeled) elif self.radio_group[1].isChecked(): if len(self.current_video_list_labeled) > 0: self.components_left[10].addItems( self.current_video_list_labeled) ################################################################################################################# def thread_update_list_min(self): # Pass the function to execute worker = Worker( self._update_list_min ) # Any other args, kwargs are passed to the run function worker.signals.result.connect(self.print_output) worker.signals.finished.connect(self.thread_complete) worker.signals.progress.connect(self.progress_fn) # Execute self.threadpool.start(worker) def _update_list_min(self, progress_callback): self.components_left[10].clear() Q_min_date = self.components_left[6].selectedDate() self.min_date = datetime.datetime.strptime( "%d-%d-%d" % (Q_min_date.year(), Q_min_date.month(), Q_min_date.day()), "%Y-%m-%d") self.components_left[8].setMinimumDate(self.min_date) self._update_video_list() ################################################################################################################# def thread_update_list_max(self): # Pass the function to execute worker = Worker( self._update_list_max ) # Any other args, kwargs are passed to the run function worker.signals.result.connect(self.print_output) worker.signals.finished.connect(self.thread_complete) worker.signals.progress.connect(self.progress_fn) # Execute self.threadpool.start(worker) def _update_list_max(self, progress_callback): self.components_left[10].clear() Q_max_date = self.components_left[8].selectedDate() self.max_date = datetime.datetime.strptime( "%d-%d-%d" % (Q_max_date.year(), Q_max_date.month(), Q_max_date.day()), "%Y-%m-%d") self._update_video_list() ################################################################################################################# def thread_update_list_radio(self): # Pass the function to execute worker = Worker( self._update_list_radio ) # Any other args, kwargs are passed to the run function worker.signals.result.connect(self.print_output) worker.signals.finished.connect(self.thread_complete) worker.signals.progress.connect(self.progress_fn) # Execute self.threadpool.start(worker) def _update_list_radio(self, progress_callback): self._update_video_list() ################################################################################################################# def thread_update_slider(self): th = threading.Thread(target=self.process_slider) th.start() def process_slider(self): while True: if self.slider_queue.qsize() > 0: self.slider.setValue(self.slider_queue.get()) ################################################################################################################# def thread_update_database(self): th = threading.Thread(target=self.update_database) th.start() def update_database(self): global FLAG_DATABASE_SAFE database_cloud_dir = os.path.join(self.root_dir, 'database') if not os.path.exists(database_cloud_dir): os.mkdir(database_cloud_dir) while True: time.sleep(60) if FLAG_DATABASE_SAFE: try: shutil.copy( self.database_local_dir, os.path.join(database_cloud_dir, os.path.basename( self.database_local_dir))) sys.stdout.write( "\r [%s] Database synchronized into %s ..." % (str(datetime.datetime.now()), database_cloud_dir)) sys.stdout.flush() except: pass else: print("Database Not Safe! Will try next time...") ################################################################################################################# def _update_video_list(self): animal = self.components_left[3].currentText() filtered_items = self.F.get_filtered_video_list( animal, self.min_date, self.max_date) sql = sqlHandler(self.database_local_dir) self.current_video_list_all = filtered_items self.current_video_list_labeled = [ item for item in self.current_video_list_all if sql.is_labeled(item) ] self.current_video_list_unlabeled = [ item for item in self.current_video_list_all if item not in self.current_video_list_labeled ] sql.close() self.components_left[10].clear() if self.radio_group[0].isChecked(): if len(self.current_video_list_unlabeled) > 0: self.components_left[10].addItems( self.current_video_list_unlabeled) elif self.radio_group[1].isChecked(): if len(self.current_video_list_labeled) > 0: self.components_left[10].addItems( self.current_video_list_labeled) def progress_fn(self, n): pass def print_output(self, s): pass def thread_complete(self): global FLAG_COMPLETE FLAG_COMPLETE = True def resizeEvent(self, event): self.overlay.resize(event.size()) event.accept()
class dicomViewWidget(QWidget): """ GENERIC DICOM VIEWER WIDGET This class defines the layout only A controller is required to do anything """ def __init__(self, parent=None, directory=None, **kwargs): super().__init__(parent=parent) self.parent = parent self.showingImage = False self.new_slice_to_show = True self.legend = None self.startingDirectory = "C:\\" # Where to begin dicom im search self.createControls() self.createAxes() self.initializeModel() centralLayout = QHBoxLayout() centralLayout.addWidget(self.PlotWidge) centralLayout.addLayout(self.viewToolsLayout) self.setLayout(centralLayout) # def autoscale(self): # for ax in self.myPlot: # ax. def createAxes(self): PlotWidge = self.PlotWidge = self.getPlotWidgeObject() PlotWidge.setBackground(None) self.myPlot = self.createViews(PlotWidge) for ax in self.myPlot: plot = self.myPlot[ax] myView = plot.getViewBox() myView.setAspectLocked(True) # myView.invertY(True) myView.setBackgroundColor('#CCCCCC') # myView.setBackgroundColor('#000000') # plot.showAxis('left', False) # plot.showAxis('bottom', False) plot.setRange(xRange=(-200, 200)) plot.hideButtons() # legend = self.legend = LegendItem() # legend.setParentItem(myPlot) def createViews(self, PlotWidge): views = {'z': PlotWidge.addPlot()} return views def getPlotWidgeObject(self): # For Default DicomViewWidget: use Default pyqtgraph Plot Widget # Can be overrode using this function in subclasses of DicomViewWidget return GraphicsLayoutWidget() def createControls(self): self.viewToolsLayout = depthLayout = QVBoxLayout() self.sliceSlider = QSlider() self.sliceSlider.setEnabled(True) self.sliceSlider.valueChanged.connect(self.sliderChanged) self.depthGauge = QLabel("0.0 mm") self.depthGauge.setMinimumWidth(50) self.sliceIndGauge = QLabel("Slice 0 / 0") self.dirFinder = QPushButton("Select Images") self.dirFinder.clicked.connect(self.selectImages) depthLayout.addWidget(self.dirFinder, 0, QtCore.Qt.AlignCenter) depthLayout.addWidget(self.depthGauge, 0, QtCore.Qt.AlignCenter) depthLayout.addWidget(self.sliceSlider, 1, QtCore.Qt.AlignHCenter) depthLayout.addWidget(self.sliceIndGauge, 0, QtCore.Qt.AlignCenter) def initializeModel(self, sliceLoc=0, sliceIndex=0): self.thisSliceLoc = sliceLoc self.thisSliceIndex = 0 self.T_MRI_Ref = np.eye(4) self.T_patient_pixels = np.eye(4) self.T_pixels_patient = np.eye(4) self.PlottableContours = {} self.sliceIndGauge.setText("Slice 0 / 0") self.depthGauge.setText("0.0 mm") self.currentUID = 0 self.UID_zero = 0 self.PlottableImage = ImageItem() def updateScene(self, sliceUID): if self.showingImage: self.PlottableImage.updatePlottable(UID=sliceUID) for contour in self.PlottableContours.values(): contour.updatePlottable(UID=sliceUID) def setupAddDataModel(self): self.dirFinder.setText("Select Images") self.dirFinder.clicked.disconnect() self.dirFinder.clicked.connect(self.selectImages) def selectImages(self): """ Open Dialog to find directory with Dicom Files """ dicomDir = QFileDialog.getExistingDirectory( parent=self, caption="Select Dicom Directory", directory=self.startingDirectory) if dicomDir is '': return # try: self.ImVolume = DicomDataModel(diDir=dicomDir) self.addImages(imageModel=self.ImVolume) def addImages(self, imageModel): # Get DicomData Pixel Transformations # self.T_patient_pixels = imageModel.PP2IMTransformation # self.T_pixels_patient = imageModel.IM2PPTransformation TPat2Pix = imageModel.TPat2Pix self.UID_zero = imageModel.Ind2UID[0] self.currentUID = self.UID_zero # Add Image Object (for DICOM pixel array) self.PlottableImage = DicomImagePlotItem(dicomModel=imageModel) self.myPlot['z'].addItem(self.PlottableImage) # self.PlottableImage.rotate(45) # Add Contour Object (if there are any!) if bool(imageModel.contourObjs): self.createContourPlottables(contourDict=imageModel.contourObjs, Pat2PixTForm=TPat2Pix, UID2IndDict=imageModel.UID2Ind) # Tidy Up self.showingImage = True for plot in self.myPlot.values(): plot.autoRange() self.configureSliceSlider() self.setupClearDataModel() def createContourPlottables(self, contourDict, *args, **kwargs): """ create/store list of 'active contour objects' for plotting also make, but don't store list of projections of contours """ self.PlottableContours = {} for ROI in contourDict['ROI']: contourP = self.getContourPlottable(ROIDict=ROI, *args, **kwargs) self.PlottableContours[ROI['ROIName']] = contourP self.myPlot['z'].addItem(contourP) if bool(self.legend): self.populateLegend(legend=self.legend, contourDict=self.PlottableContours) def getContourPlottable(self, *args, **kwargs): return DicomContourPlotItem(*args, **kwargs) def setupClearDataModel(self): """ Change bttn function to be CLEAR DATA """ self.dirFinder.setText("Clear Data") self.dirFinder.clicked.disconnect() self.dirFinder.clicked.connect(self.clearImagesWarning) def clearImagesWarning(self, **kwargs): """ Confirm with User that they want to Clear Plot""" qbb = QDialog(**kwargs) qbb.setWindowTitle("Clear Data?") qbb.setWindowModality(QtCore.Qt.ApplicationModal) ok = QPushButton("Clear") no = QPushButton("Cancel") ok.clicked.connect(self.clearImages) ok.clicked.connect(qbb.close) no.clicked.connect(qbb.close) layout = QVBoxLayout(qbb) layout.addWidget(QLabel("Are you sure you want to clear data?")) layout.addSpacing(20) bttnLayout = QHBoxLayout() bttnLayout.addWidget(ok) bttnLayout.addWidget(no) layout.addLayout(bttnLayout) qbb.exec_() def clearImages(self): """ Reset and Clear Axes """ self.myPlot['z'].clear() # for item in [self.PlottableImage]: # del item self.showingImage = False if bool(self.legend): self.clearLegend(self.legend) self.initializeModel() self.setupAddDataModel() def configureSliceSlider(self): dicomMin = min(self.ImVolume.Loc2Ind.keys()) dicomMax = max(self.ImVolume.Loc2Ind.keys()) # dicomRange = dicomMax - dicomMin self.sliceSlider.setEnabled(True) self.sliceSlider.setRange(dicomMin, dicomMax) self.sliceSlider.setValue(dicomMin) self.sliderChanged() def sliderChanged(self): if not self.showingImage: return """ on change of SliceSlider value: """ newSliderVal = self.sliceSlider.value() newSliceLoc = min(self.ImVolume.Loc2Ind.keys(), key=lambda x: abs(x - newSliderVal)) newSliceIndex = self.ImVolume.Loc2Ind[newSliceLoc] newSliceLoc = round(newSliceLoc * 1000) / 1000 maxInd = max(self.ImVolume.Ind2Loc.keys()) self.depthGauge.setText("{:>1.2f} mm".format(newSliceLoc)) self.sliceIndGauge.setText("Slice {}/{}".format(newSliceIndex, maxInd)) newUID = self.ImVolume.Ind2UID[newSliceIndex] if not newUID == self.currentUID: self.currentUID = newUID self.updateScene(sliceUID=newUID) def updateGauges(self, newSliderVal=0): newSliderVal = self.dispView.sliceSlider.value() newSliceLocation = min(self.ImVolume.sliceLoc2Ind.keys(), key=lambda x: abs(x - newSliderVal)) newSliceIndex = self.ImVolume.sliceLoc2Ind[newSliceLocation] self.thisSliceIndex = newSliceIndex self.thisSliceLoc = newSliceLocation def populateLegend(self, legend, contourDict={}): for thisContour in contourDict: legend.addItem(item=contourDict[thisContour], name=(' ' + thisContour)) def clearLegend(self, legend): legend.items = [] while legend.layout.count() > 0: legend.layout.removeAt(0) self.myPlot.removeItem(legend) def closeEvent(self, event): print("Closing the app") self.deleteLater()
def createSlider(self, sliderName='Slider', tickInterval=10, tickStep=1, min=0, max=50): """ Function to create slider on main window INPUTS :sliderName: String of what label to put on slider :tickInterval: Interval of how much hotkey should increment by :tickStep: What is the minimum amount of change that can occur on slider :min: Min value of slider :max: Max value of slider OUTPUTS :groupBox: PyQt5 object for bbox of slider and contents :slider: Resulting set slider object """ groupBox = QGroupBox(sliderName) # Create container for GUI objects slider = QSlider(Qt.Horizontal) # Create slider slider.setFocusPolicy(Qt.StrongFocus) # Set style slider.setTickPosition(QSlider.TicksBothSides) # Set functionality slider.setTickInterval(tickInterval) # Set tick interval slider.setSingleStep(tickStep) # Set min step slider.setMinimum(min) # Set min value slider.setMaximum(max) # Set max balue vbox=QVBoxLayout() # Put slider in bbox then add to container vbox.addWidget(slider) vbox.addStretch(1) groupBox.setLayout(vbox) return groupBox, slider
def multisig_dialog(self, run_next): cw = CosignWidget(2, 2) m_edit = QSlider(Qt.Horizontal, self) n_edit = QSlider(Qt.Horizontal, self) n_edit.setMinimum(2) n_edit.setMaximum(15) m_edit.setMinimum(1) m_edit.setMaximum(2) n_edit.setValue(2) m_edit.setValue(2) n_label = QLabel() m_label = QLabel() grid = QGridLayout() grid.addWidget(n_label, 0, 0) grid.addWidget(n_edit, 0, 1) grid.addWidget(m_label, 1, 0) grid.addWidget(m_edit, 1, 1) def on_m(m): m_label.setText(_('Require {0} signatures').format(m)) cw.set_m(m) def on_n(n): n_label.setText(_('From {0} cosigners').format(n)) cw.set_n(n) m_edit.setMaximum(n) n_edit.valueChanged.connect(on_n) m_edit.valueChanged.connect(on_m) on_n(2) on_m(2) vbox = QVBoxLayout() vbox.addWidget(cw) vbox.addWidget(WWLabel(_("Choose the number of signatures needed to unlock funds in your wallet:"))) vbox.addLayout(grid) self.exec_layout(vbox, _("Multi-Signature Wallet")) m = int(m_edit.value()) n = int(n_edit.value()) return (m, n)
selectionGroupBox = QGroupBox("Selection Mode") modeNoneRB = QRadioButton("No selection") modeItemRB = QRadioButton("Item") modeSliceRowRB = QRadioButton("Row Slice") modeSliceColumnRB = QRadioButton("Column Slice") selectionVBox = QVBoxLayout() selectionVBox.addWidget(modeNoneRB) selectionVBox.addWidget(modeItemRB) selectionVBox.addWidget(modeSliceRowRB) selectionVBox.addWidget(modeSliceColumnRB) selectionGroupBox.setLayout(selectionVBox) axisMinSliderX = QSlider(Qt.Horizontal, minimum=0, tickInterval=1) axisMaxSliderX = QSlider(Qt.Horizontal, minimum=1, tickInterval=1) axisMinSliderZ = QSlider(Qt.Horizontal, minimum=0, tickInterval=1) axisMaxSliderZ = QSlider(Qt.Horizontal, minimum=1, tickInterval=1) rhoSlider = QSlider(Qt.Horizontal, minimum=0, maximum=200, tickInterval=1) rhoSlider.setValue(int(-0.4082482904638631 * 100) + 100) themeList = QComboBox() themeList.addItem("Qt") themeList.addItem("Primary Colors") themeList.addItem("Digia") themeList.addItem("Stone Moss") themeList.addItem("Army Blue") themeList.addItem("Retro") themeList.addItem("Ebony")
class MyApp(QWidget): def __init__(self): super().__init__() # 파이썬 실행창을 항상 위로 유지해주는 코드 self.setWindowFlags(Qt.WindowStaysOnTopHint) self.initUI() def initUI(self): #서버에서 json 값을 받아와 data 변수에 저장 url = "http://ec2-54-180-94-182.ap-northeast-2.compute.amazonaws.com:3000/desk/qr" data = requests.get(url).json() # data 딕셔너리 중 randomNum 키의 value 값으로 qr코드 생성, 추후 다른 키 값과 조합하여 수정 예정 self.setStyleSheet("background-color: #FFFFFF") qr = qrcode.QRCode( version=1, error_correction=qrcode.constants.ERROR_CORRECT_L, box_size=10, border=0, ) qr.add_data(str(data['id']) + data['randomNum']) qr.make(fit=True) img = qr.make_image(fill_color="black", back_color="white") qt_image = ImageQt.ImageQt(img) self.pixmap = QPixmap.fromImage(qt_image) self.lbl_img = QLabel() self.lbl_img.setPixmap(self.pixmap) self.vbox = QVBoxLayout() self.vbox.addWidget(self.lbl_img) self.setLayout(self.vbox) self.slider = QSlider(Qt.Horizontal, self) self.slider.setRange(10, 90) self.vbox.addWidget(self.slider) self.btn = QPushButton('초기화', self) self.vbox.addWidget(self.btn) self.slider.valueChanged.connect(self.setOpacity) self.btn.clicked.connect(self.button_clicked) self.setWindowTitle('투명도 조절') self.move(300, 300) self.show() t = threading.Thread(target=self.refreshImg) t.start() def refreshImg(self): url = "http://ec2-54-180-94-182.ap-northeast-2.compute.amazonaws.com:3000/desk/qr" while True: data = requests.get(url).json() img = qrcode.make(str(data['id']) + data['randomNum']) qt_image = ImageQt.ImageQt(img) self.pixmap = QPixmap.fromImage(qt_image) self.lbl_img.setPixmap(self.pixmap) time.sleep(1) def button_clicked(self): self.slider.setValue(1) def setOpacity(self, value): value = 1.1 - (value / 100) self.setWindowOpacity(value)
def __init__(self, window, plugin, keystore, device_id): title = _("{} Settings").format(plugin.device) super(SettingsDialog, self).__init__(window, title) self.setMaximumWidth(540) devmgr = plugin.device_manager() config = devmgr.config handler = keystore.handler thread = keystore.thread hs_cols, hs_rows = (128, 64) def invoke_client(method, *args, **kw_args): unpair_after = kw_args.pop('unpair_after', False) def task(): client = devmgr.client_by_id(device_id) if not client: raise RuntimeError("Device not connected") if method: getattr(client, method)(*args, **kw_args) if unpair_after: devmgr.unpair_id(device_id) return client.features thread.add(task, on_success=update) def update(features): self.features = features set_label_enabled() if features.bootloader_hash: bl_hash = bh2u(features.bootloader_hash) bl_hash = "\n".join([bl_hash[:32], bl_hash[32:]]) else: bl_hash = "N/A" noyes = [_("No"), _("Yes")] endis = [_("Enable Passphrases"), _("Disable Passphrases")] disen = [_("Disabled"), _("Enabled")] setchange = [_("Set a PIN"), _("Change PIN")] version = "%d.%d.%d" % (features.major_version, features.minor_version, features.patch_version) device_label.setText(features.label) pin_set_label.setText(noyes[features.pin_protection]) passphrases_label.setText(disen[features.passphrase_protection]) bl_hash_label.setText(bl_hash) label_edit.setText(features.label) device_id_label.setText(features.device_id) initialized_label.setText(noyes[features.initialized]) version_label.setText(version) clear_pin_button.setVisible(features.pin_protection) clear_pin_warning.setVisible(features.pin_protection) pin_button.setText(setchange[features.pin_protection]) pin_msg.setVisible(not features.pin_protection) passphrase_button.setText(endis[features.passphrase_protection]) language_label.setText(features.language) def set_label_enabled(): label_apply.setEnabled(label_edit.text() != self.features.label) def rename(): invoke_client('change_label', label_edit.text()) def toggle_passphrase(): title = _("Confirm Toggle Passphrase Protection") currently_enabled = self.features.passphrase_protection if currently_enabled: msg = _("After disabling passphrases, you can only pair this " "ElectrumSys wallet if it had an empty passphrase. " "If its passphrase was not empty, you will need to " "create a new wallet with the install wizard. You " "can use this wallet again at any time by re-enabling " "passphrases and entering its passphrase.") else: msg = _( "Your current ElectrumSys wallet can only be used with " "an empty passphrase. You must create a separate " "wallet with the install wizard for other passphrases " "as each one generates a new set of addresses.") msg += "\n\n" + _("Are you sure you want to proceed?") if not self.question(msg, title=title): return invoke_client('toggle_passphrase', unpair_after=currently_enabled) def change_homescreen(): filename = getOpenFileName( parent=self, title=_("Choose Homescreen"), config=config, ) if not filename: return # user cancelled if filename.endswith('.toif'): img = open(filename, 'rb').read() if img[:8] != b'TOIf\x90\x00\x90\x00': handler.show_error( 'File is not a TOIF file with size of 144x144') return else: from PIL import Image # FIXME im = Image.open(filename) if im.size != (128, 64): handler.show_error('Image must be 128 x 64 pixels') return im = im.convert('1') pix = im.load() img = bytearray(1024) for j in range(64): for i in range(128): if pix[i, j]: o = (i + j * 128) img[o // 8] |= (1 << (7 - o % 8)) img = bytes(img) invoke_client('change_homescreen', img) def clear_homescreen(): invoke_client('change_homescreen', b'\x00') def set_pin(): invoke_client('set_pin', remove=False) def clear_pin(): invoke_client('set_pin', remove=True) def wipe_device(): wallet = window.wallet if wallet and sum(wallet.get_balance()): title = _("Confirm Device Wipe") msg = _("Are you SURE you want to wipe the device?\n" "Your wallet still has syscoins in it!") if not self.question( msg, title=title, icon=QMessageBox.Critical): return invoke_client('wipe_device', unpair_after=True) def slider_moved(): mins = timeout_slider.sliderPosition() timeout_minutes.setText(_("{:2d} minutes").format(mins)) def slider_released(): config.set_session_timeout(timeout_slider.sliderPosition() * 60) # Information tab info_tab = QWidget() info_layout = QVBoxLayout(info_tab) info_glayout = QGridLayout() info_glayout.setColumnStretch(2, 1) device_label = QLabel() pin_set_label = QLabel() passphrases_label = QLabel() version_label = QLabel() device_id_label = QLabel() bl_hash_label = QLabel() bl_hash_label.setWordWrap(True) language_label = QLabel() initialized_label = QLabel() rows = [ (_("Device Label"), device_label), (_("PIN set"), pin_set_label), (_("Passphrases"), passphrases_label), (_("Firmware Version"), version_label), (_("Device ID"), device_id_label), (_("Bootloader Hash"), bl_hash_label), (_("Language"), language_label), (_("Initialized"), initialized_label), ] for row_num, (label, widget) in enumerate(rows): info_glayout.addWidget(QLabel(label), row_num, 0) info_glayout.addWidget(widget, row_num, 1) info_layout.addLayout(info_glayout) # Settings tab settings_tab = QWidget() settings_layout = QVBoxLayout(settings_tab) settings_glayout = QGridLayout() # Settings tab - Label label_msg = QLabel( _("Name this {}. If you have multiple devices " "their labels help distinguish them.").format(plugin.device)) label_msg.setWordWrap(True) label_label = QLabel(_("Device Label")) label_edit = QLineEdit() label_edit.setMinimumWidth(150) label_edit.setMaxLength(plugin.MAX_LABEL_LEN) label_apply = QPushButton(_("Apply")) label_apply.clicked.connect(rename) label_edit.textChanged.connect(set_label_enabled) settings_glayout.addWidget(label_label, 0, 0) settings_glayout.addWidget(label_edit, 0, 1, 1, 2) settings_glayout.addWidget(label_apply, 0, 3) settings_glayout.addWidget(label_msg, 1, 1, 1, -1) # Settings tab - PIN pin_label = QLabel(_("PIN Protection")) pin_button = QPushButton() pin_button.clicked.connect(set_pin) settings_glayout.addWidget(pin_label, 2, 0) settings_glayout.addWidget(pin_button, 2, 1) pin_msg = QLabel( _("PIN protection is strongly recommended. " "A PIN is your only protection against someone " "stealing your syscoins if they obtain physical " "access to your {}.").format(plugin.device)) pin_msg.setWordWrap(True) pin_msg.setStyleSheet("color: red") settings_glayout.addWidget(pin_msg, 3, 1, 1, -1) # Settings tab - Homescreen homescreen_label = QLabel(_("Homescreen")) homescreen_change_button = QPushButton(_("Change...")) homescreen_clear_button = QPushButton(_("Reset")) homescreen_change_button.clicked.connect(change_homescreen) try: import PIL except ImportError: homescreen_change_button.setDisabled(True) homescreen_change_button.setToolTip( _("Required package 'PIL' is not available - Please install it or use the Trezor website instead." )) homescreen_clear_button.clicked.connect(clear_homescreen) homescreen_msg = QLabel( _("You can set the homescreen on your " "device to personalize it. You must " "choose a {} x {} monochrome black and " "white image.").format(hs_cols, hs_rows)) homescreen_msg.setWordWrap(True) settings_glayout.addWidget(homescreen_label, 4, 0) settings_glayout.addWidget(homescreen_change_button, 4, 1) settings_glayout.addWidget(homescreen_clear_button, 4, 2) settings_glayout.addWidget(homescreen_msg, 5, 1, 1, -1) # Settings tab - Session Timeout timeout_label = QLabel(_("Session Timeout")) timeout_minutes = QLabel() timeout_slider = QSlider(Qt.Horizontal) timeout_slider.setRange(1, 60) timeout_slider.setSingleStep(1) timeout_slider.setTickInterval(5) timeout_slider.setTickPosition(QSlider.TicksBelow) timeout_slider.setTracking(True) timeout_msg = QLabel( _("Clear the session after the specified period " "of inactivity. Once a session has timed out, " "your PIN and passphrase (if enabled) must be " "re-entered to use the device.")) timeout_msg.setWordWrap(True) timeout_slider.setSliderPosition(config.get_session_timeout() // 60) slider_moved() timeout_slider.valueChanged.connect(slider_moved) timeout_slider.sliderReleased.connect(slider_released) settings_glayout.addWidget(timeout_label, 6, 0) settings_glayout.addWidget(timeout_slider, 6, 1, 1, 3) settings_glayout.addWidget(timeout_minutes, 6, 4) settings_glayout.addWidget(timeout_msg, 7, 1, 1, -1) settings_layout.addLayout(settings_glayout) settings_layout.addStretch(1) # Advanced tab advanced_tab = QWidget() advanced_layout = QVBoxLayout(advanced_tab) advanced_glayout = QGridLayout() # Advanced tab - clear PIN clear_pin_button = QPushButton(_("Disable PIN")) clear_pin_button.clicked.connect(clear_pin) clear_pin_warning = QLabel( _("If you disable your PIN, anyone with physical access to your " "{} device can spend your syscoins.").format(plugin.device)) clear_pin_warning.setWordWrap(True) clear_pin_warning.setStyleSheet("color: red") advanced_glayout.addWidget(clear_pin_button, 0, 2) advanced_glayout.addWidget(clear_pin_warning, 1, 0, 1, 5) # Advanced tab - toggle passphrase protection passphrase_button = QPushButton() passphrase_button.clicked.connect(toggle_passphrase) passphrase_msg = WWLabel(PASSPHRASE_HELP) passphrase_warning = WWLabel(PASSPHRASE_NOT_PIN) passphrase_warning.setStyleSheet("color: red") advanced_glayout.addWidget(passphrase_button, 3, 2) advanced_glayout.addWidget(passphrase_msg, 4, 0, 1, 5) advanced_glayout.addWidget(passphrase_warning, 5, 0, 1, 5) # Advanced tab - wipe device wipe_device_button = QPushButton(_("Wipe Device")) wipe_device_button.clicked.connect(wipe_device) wipe_device_msg = QLabel( _("Wipe the device, removing all data from it. The firmware " "is left unchanged.")) wipe_device_msg.setWordWrap(True) wipe_device_warning = QLabel( _("Only wipe a device if you have the recovery seed written down " "and the device wallet(s) are empty, otherwise the syscoins " "will be lost forever.")) wipe_device_warning.setWordWrap(True) wipe_device_warning.setStyleSheet("color: red") advanced_glayout.addWidget(wipe_device_button, 6, 2) advanced_glayout.addWidget(wipe_device_msg, 7, 0, 1, 5) advanced_glayout.addWidget(wipe_device_warning, 8, 0, 1, 5) advanced_layout.addLayout(advanced_glayout) advanced_layout.addStretch(1) tabs = QTabWidget(self) tabs.addTab(info_tab, _("Information")) tabs.addTab(settings_tab, _("Settings")) tabs.addTab(advanced_tab, _("Advanced")) dialog_vbox = QVBoxLayout(self) dialog_vbox.addWidget(tabs) dialog_vbox.addLayout(Buttons(CloseButton(self))) # Update information invoke_client(None)
def __init__(self, setup: Setup): super().__init__() self.setWindowFlags(Qt.Window) self.setWindowTitle("Composite Enthalpy Diagram") self._setup = setup self._figure = Figure() self._canvas = FigureCanvasQTAgg(self._figure) self._plt_toolbar = NavigationToolbar2QT(self._canvas, self) slider = QSlider(self) self._slider = slider slider.setValue(self._setup.dt) slider.setMinimum(5) slider.setMaximum(30) slider.setSingleStep(2) slider.setOrientation(Qt.Horizontal) slider.sliderReleased.connect(self._on_dt_changed) setup.dt_changed.connect(self._plot_graph) layout = QVBoxLayout() layout.addWidget(slider) layout.addWidget(self._canvas) layout.addWidget(self._plt_toolbar) self.setLayout(layout) self._plot_graph()
class DW(QDockWidget): key_pressed_signal = pyqtSignal(QEvent) volume_slider_moved_signal = pyqtSignal(int, int) view_signal = pyqtSignal(int, str, int) def __init__(self, id_, parent=None): super().__init__(parent) self.id_ = id_ self.zoomed = False self.setWindowTitle(f"Player #{id_ + 1}") self.setObjectName(f"player{id_ + 1}") self.stack1 = QWidget() self.hlayout = QHBoxLayout() self.videoframe = Video_frame() self.videoframe.video_frame_signal.connect(self.view_signal_triggered) self.palette = self.videoframe.palette() self.palette.setColor(QPalette.Window, QColor(0, 0, 0)) self.videoframe.setPalette(self.palette) self.videoframe.setAutoFillBackground(True) self.hlayout.addWidget(self.videoframe) self.volume_slider = QSlider(Qt.Vertical, self) self.volume_slider.setMaximum(100) self.volume_slider.setValue(50) self.volume_slider.sliderMoved.connect(self.volume_slider_moved) self.hlayout.addWidget(self.volume_slider) self.stack1.setLayout(self.hlayout) self.stack2 = QWidget() self.hlayout2 = QHBoxLayout() self.frame_viewer = Click_label(id_) self.frame_viewer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.frame_viewer.setAlignment(Qt.AlignCenter) self.frame_viewer.setStyleSheet("QLabel {background-color: black;}") self.hlayout2.addWidget(self.frame_viewer) self.stack2.setLayout(self.hlayout2) self.stack = QStackedWidget(self) self.stack.addWidget(self.stack1) self.stack.addWidget(self.stack2) self.setWidget(self.stack) def volume_slider_moved(self): """ emit signal when volume slider moved """ self.volume_slider_moved_signal.emit(self.id_, self.volume_slider.value()) def keyPressEvent(self, event): """ emit signal when key pressed on dock widget """ self.key_pressed_signal.emit(event) def view_signal_triggered(self, msg, button): """ transmit signal received by video frame """ self.view_signal.emit(self.id_, msg, button)
class Conway(QWidget): """A PyQtWidget with all elements necessary to implement the famous Conway's game of life application.""" def __init__(self): super().__init__() self.title = "Conway's Game of Life" self.width = 400 self.height = 600 self.baseSpeed = 101 self.aliveColor = QtCore.Qt.blue self.deadColor = QtCore.Qt.white self.speed = self.baseSpeed self.initUI() self.center() self.gosper = False self.gridSize = 20 self.squareSize = 50 self.grid = np.random.randint(2, size=(self.gridSize, self.gridSize)) def center(self): "Centers the Conway object window on the desktop." qr = self.frameGeometry() cp = QDesktopWidget().availableGeometry().center() qr.moveCenter(cp) self.move(qr.topLeft()) def getNeighbors(self, pos): """Retrieve a list of neighbors in a given cell. Conway's game of life is governed by rules involving the neighboring cells of each cell on the game board. This function identifies the neighbor cells of a given position on the grid, so that the rules may be applied to the subject cell. For the Gosper Glider Gun, the sides of the game board are unstitched, as the gliders are intended to go on forever without interfering with their source. """ up_row = pos[0] - 1 down_row = pos[0] + 1 left_col = pos[1] - 1 right_col = pos[1] + 1 if self.gosper: neighbor_list = [(up_row, left_col), (up_row, pos[1]), (up_row, right_col), (pos[0], left_col), (pos[0], right_col), (down_row, left_col), (down_row, pos[1]), (down_row, right_col)] if up_row < 0: try: neighbor_list.remove((up_row, left_col)) neighbor_list.remove((up_row, pos[1])) neighbor_list.remove((up_row, right_col)) except ValueError: pass if left_col < 0: try: neighbor_list.remove((up_row, left_col)) except ValueError: pass neighbor_list.remove((pos[0], left_col)) neighbor_list.remove((down_row, left_col)) if down_row > self.gridSize - 1: try: neighbor_list.remove((down_row, left_col)) except ValueError: pass neighbor_list.remove((down_row, pos[1])) neighbor_list.remove((down_row, right_col)) if right_col > self.gridSize - 1: try: neighbor_list.remove((up_row, right_col)) except ValueError: pass try: neighbor_list.remove((down_row, right_col)) except ValueError: pass neighbor_list.remove((pos[0], right_col)) else: if up_row < 0: up_row = self.gridSize - 1 if left_col < 0: left_col = self.gridSize - 1 if down_row > self.gridSize - 1: down_row = 0 if right_col > self.gridSize - 1: right_col = 0 neighbor_list = [(up_row, left_col), (up_row, pos[1]), (up_row, right_col), (pos[0], left_col), (pos[0], right_col), (down_row, left_col), (down_row, pos[1]), (down_row, right_col)] return neighbor_list def goToNextGen(self): """Calculate the next generation of cells. Uses the rules of Conway's Game of Life to create a new generation of cells based on the current generation of cells, then updates the window so the Painter object re-draws the grid. Conway's Game of Life Rules (per Wikipedia): 1. Any live cell with two or three live neighbours survives. 2. Any dead cell with three live neighbours becomes a live cell. 3. All other live cells die in the next generation. Similarly, all other dead cells stay dead. """ nextgen = np.array([[0] * self.gridSize] * self.gridSize) for i in range(self.gridSize): for j in range(self.gridSize): neighbors = self.getNeighbors((i, j)) testsum = self.grid[i, j] for n in neighbors: testsum += self.grid[n[0], n[1]] if testsum == 3: nextgen[i, j] = 1 elif testsum == 4: nextgen[i, j] = self.grid[i, j] else: nextgen[i, j] = 0 self.grid = nextgen self.update() def initUI(self): """Initialize User Interface Populates the window with userful UI elements, including: 1. Start, Pause, and Reset buttons. 2. A speed slider. 3. Color selection buttons and associated dialogs 4. Pulsar, Penta-Decathalon, and Gosper Glider Gun buttons, which change the initial state of the application for predictable results. The initial states are read in from provided CSV files. Each of these elements are connected to functions that materialize their effects in the game board. """ self.setWindowTitle(self.title) self.setFixedSize(self.width, self.height) # Media Buttons self.btnStart = QPushButton(self) self.btnStart.setGeometry(QtCore.QRect(155, 365, 45, 25)) self.btnStart.setIcon(self.style().standardIcon( getattr(QStyle, 'SP_MediaPlay'))) self.btnStart.setToolTip('Start') self.btnPause = QPushButton(self) self.btnPause.setGeometry(QtCore.QRect(195, 365, 45, 25)) self.btnPause.setIcon(self.style().standardIcon( getattr(QStyle, 'SP_MediaPause'))) self.btnPause.setToolTip('Pause') # Speed Slider lblSlow = QLabel("Slow", self) lblSlow.setGeometry(QtCore.QRect(65, 400, 25, 25)) self.slSpeed = QSlider(QtCore.Qt.Horizontal, parent=self) self.slSpeed.setGeometry(QtCore.QRect(96, 400, 200, 25)) self.slSpeed.setMinimum(-10) self.slSpeed.setMaximum(10) self.slSpeed.setValue(0) self.slSpeed.setTickPosition(QSlider.TicksBelow) self.slSpeed.setTickInterval(1) self.slSpeed.setToolTip('Change tick speed.') lblFast = QLabel("Fast", self) lblFast.setGeometry(QtCore.QRect(305, 400, 25, 25)) # Color Selection group = QGroupBox("Change Colors", self) grid = QGridLayout() self.btnAliveColor = QPushButton("Alive...", self) self.btnAliveColor.setToolTip('Change color of alive cells.') self.btnDeadColor = QPushButton("Dead...", self) self.btnDeadColor.setToolTip('Change color of dead cells.') grid.addWidget(self.btnAliveColor, 0, 0) grid.addWidget(self.btnDeadColor, 0, 1) group.setLayout(grid) group.setGeometry(QtCore.QRect(35, 435, 325, 60)) # Starting Conditions group = QGroupBox("Starting Conditions", self) grid = QGridLayout() self.btnPulsar = QPushButton("Pulsar", self) self.btnPulsar.setToolTip("Change to 'Pulsar' initial state.") self.btnPenta = QPushButton("Penta-Decathalon", self) self.btnPenta.setToolTip("Change to 'Penta-Decathalon' initial state.") self.btnGosper = QPushButton("Gosper Glider Gun", self) self.btnGosper.setToolTip("Change to 'Gosper Glider Gun' " + "initial state.") grid.addWidget(self.btnPulsar, 0, 0) grid.addWidget(self.btnPenta, 0, 1) grid.addWidget(self.btnGosper, 0, 2) group.setLayout(grid) group.setGeometry(QtCore.QRect(35, 500, 325, 60)) # Reset Button self.btnReset = QPushButton('Reset', self) self.btnReset.setGeometry(QtCore.QRect(155, 565, 90, 25)) self.btnReset.setToolTip("Reset program to a random initial state.") self.show() self.btnStart.clicked.connect(self.onClickStart) self.btnPause.clicked.connect(self.onClickPause) self.slSpeed.valueChanged.connect(self.onSpeedChange) self.btnReset.clicked.connect(self.onClickReset) self.btnAliveColor.clicked.connect(self.onClickAliveColor) self.btnDeadColor.clicked.connect(self.onClickDeadColor) self.btnPulsar.clicked.connect(self.onClickPulsar) self.btnPenta.clicked.connect(self.onClickPenta) self.btnGosper.clicked.connect(self.onClickGosper) def onClickAliveColor(self): "Changes the color of living cells to the user's choice." self.running = False self.aliveColor = QColorDialog.getColor() def onClickDeadColor(self): "Changes the color of dead cells to the user's choice." self.running = False self.deadColor = QColorDialog.getColor() def onClickGosper(self): "Changes the initial state of the game to the Gosper Glider Gun." self.running = False self.gosper = True self.baseSpeed = 101 self.slSpeed.setValue(0) self.gridSize = 50 self.squareSize = 20 self.grid = np.loadtxt(open(ROOT + "inputs/gosper.txt", "rb"), delimiter=",").T self.update() def onClickPause(self): "Pauses Conway's game of life on the game board." self.running = False def onClickPenta(self): "Changes the initial state of the game to the Penta-Decathalon." self.running = False self.baseSpeed = 801 self.speed = self.baseSpeed self.slSpeed.setValue(0) self.gridSize = 20 self.squareSize = 50 self.grid = np.loadtxt(open(ROOT + "inputs/penta.txt", "rb"), delimiter=",").T self.update() def onClickPulsar(self): "Changes the initial state of the game to the Pulsar." self.running = False self.baseSpeed = 801 self.speed = self.baseSpeed self.slSpeed.setValue(0) self.gridSize = 20 self.squareSize = 50 self.grid = np.loadtxt(open(ROOT + "inputs/pulsar.txt", "rb"), delimiter=",").T self.update() def onClickReset(self): """Resets the game to its initial state. This means a random intial state for the game board, blue and white for alive and dead colors respectively, and changing the base speed back to 101.""" self.running = False self.aliveColor = QtCore.Qt.blue self.deadColor = QtCore.Qt.white self.gridSize = 20 self.squareSize = 50 self.base_speed = 101 self.speed = self.baseSpeed self.slSpeed.setValue(0) self.grid = np.random.randint(2, size=(self.gridSize, self.gridSize)) self.update() def onClickStart(self): "Runs Conway's game of life on the game board." self.running = True while self.running: QtTest.QTest.qWait(self.speed) self.goToNextGen() def onSpeedChange(self): """Changes the speed of Conway's game of life by increasing or decreasing the time in between updates.""" self.speed = self.baseSpeed + (self.slSpeed.value() * -(self.baseSpeed * 0.1)) def paintEvent(self, event): """Creates a painter object to construct a visual representation of Conway's Game of Life.""" painter = QPainter(self) painter.setPen(QPen(QtCore.Qt.black, 1, QtCore.Qt.SolidLine)) painter.setWindow(-100, -50, 1200, 1800) for row in range(self.gridSize): for col in range(self.gridSize): if self.grid[row, col] == 0: painter.setBrush( QBrush(self.deadColor, QtCore.Qt.SolidPattern)) painter.drawRect(row * self.squareSize, col * self.squareSize, self.squareSize, self.squareSize) else: painter.setBrush( QBrush(self.aliveColor, QtCore.Qt.SolidPattern)) painter.drawRect(row * self.squareSize, col * self.squareSize, self.squareSize, self.squareSize)
def set_layout(self) -> None: self.plot_tabs = QTabWidget() map_tab = QWidget() map_layout = QVBoxLayout() map_tab.setLayout(map_layout) self.map_plot = MapCanvas(parent=self, width=5, height=4) self.map_plot.move(0, 0) self.time_plot = TimeCanvas(parent=self, width=5, height=4) self.time_plot.move(0, 0) map_toolbar = NavigationToolbar2QT(self.map_plot, map_tab) map_toolbar.setVisible(False) map_layout.addWidget(map_toolbar) map_layout.addWidget(self.map_plot) map_toolbar.pan() time_tab = QWidget() time_layout = QVBoxLayout() time_tab.setLayout(time_layout) self.y_selector = QListWidget() self.sec_y_selector = QListWidget() self.y_selector.setSelectionMode(3) # extended selection self.sec_y_selector.setSelectionMode(3) # extended selection selector = QHBoxLayout() selector.addWidget(self.y_selector) selector.addWidget(self.sec_y_selector) time_layout.addLayout(selector) time_layout.addWidget(self.time_plot) self.plot_tabs.addTab(map_tab, "Map") self.plot_tabs.addTab(time_tab, "Plots") plot_column = QVBoxLayout() plot_column.addWidget(self.plot_tabs) self.interact_column = QVBoxLayout() self.open_options = ["Open file", "dump1090"] if "decoders" in config: self.open_options += list(config["decoders"]) self.open_dropdown = QComboBox() for option in self.open_options: self.open_dropdown.addItem(option) self.interact_column.addWidget(self.open_dropdown) self.projections = ["EuroPP", "Lambert93", "Mercator"] self.projection_dropdown = QComboBox() more_projs = config.get("projections", "extra", fallback="") if more_projs != "": proj_list = more_projs.split(";") self.projections += list(x.strip() for x in proj_list) for proj in self.projections: self.projection_dropdown.addItem(proj) self.interact_column.addWidget(self.projection_dropdown) button_grid = QGridLayout() self.extent_button = QPushButton("Extent") button_grid.addWidget(self.extent_button, 0, 0) self.plot_button = QPushButton("Plot") button_grid.addWidget(self.plot_button, 0, 1) self.airport_button = QPushButton("Airport") button_grid.addWidget(self.airport_button, 1, 0) self.reset_button = QPushButton("Reset") button_grid.addWidget(self.reset_button, 1, 1) self.interact_column.addLayout(button_grid) self.area_input_description = QLabel("Area") self.area_input = QLineEdit() area_input_layout = QHBoxLayout() area_input_layout.addWidget(self.area_input_description) area_input_layout.addWidget(self.area_input) self.interact_column.addLayout(area_input_layout) self.area_select = QListWidget() self.interact_column.addWidget(self.area_select) self.time_slider = QSlider(QtCore.Qt.Horizontal) self.time_description = QLabel("Date max.") self.time_slider_info = QLabel() time_layout = QHBoxLayout() time_layout.addWidget(self.time_description) time_layout.addWidget(self.time_slider) time_layout.addWidget(self.time_slider_info) self.time_slider.setMinimum(0) self.time_slider.setMaximum(99) self.time_slider.setValue(99) self.time_slider.setEnabled(False) self.interact_column.addLayout(time_layout) self.altitude_slider = QSlider(QtCore.Qt.Horizontal) self.altitude_description = QLabel("Altitude max.") self.altitude_slider_info = QLabel("60000") self.altitude_slider.setSingleStep(5) self.altitude_slider.setPageStep(100) self.altitude_slider.setMinimum(0) self.altitude_slider.setMaximum(600) self.altitude_slider.setValue(600) altitude_layout = QHBoxLayout() altitude_layout.addWidget(self.altitude_description) altitude_layout.addWidget(self.altitude_slider) altitude_layout.addWidget(self.altitude_slider_info) self.interact_column.addLayout(altitude_layout) self.identifier_description = QLabel("Callsign/ID") self.identifier_input = QLineEdit() identifier_layout = QHBoxLayout() identifier_layout.addWidget(self.identifier_description) identifier_layout.addWidget(self.identifier_input) self.interact_column.addLayout(identifier_layout) self.identifier_select = QListWidget() self.identifier_select.setSelectionMode(3) # extended selection self.interact_column.addWidget(self.identifier_select) mainLayout = QGridLayout() mainLayout.addLayout(plot_column, 0, 0) mainLayout.addLayout(self.interact_column, 0, 1) mainWidget = QWidget() mainWidget.setLayout(mainLayout) self.setCentralWidget(mainWidget)
def initUI(self): """Initialize User Interface Populates the window with userful UI elements, including: 1. Start, Pause, and Reset buttons. 2. A speed slider. 3. Color selection buttons and associated dialogs 4. Pulsar, Penta-Decathalon, and Gosper Glider Gun buttons, which change the initial state of the application for predictable results. The initial states are read in from provided CSV files. Each of these elements are connected to functions that materialize their effects in the game board. """ self.setWindowTitle(self.title) self.setFixedSize(self.width, self.height) # Media Buttons self.btnStart = QPushButton(self) self.btnStart.setGeometry(QtCore.QRect(155, 365, 45, 25)) self.btnStart.setIcon(self.style().standardIcon( getattr(QStyle, 'SP_MediaPlay'))) self.btnStart.setToolTip('Start') self.btnPause = QPushButton(self) self.btnPause.setGeometry(QtCore.QRect(195, 365, 45, 25)) self.btnPause.setIcon(self.style().standardIcon( getattr(QStyle, 'SP_MediaPause'))) self.btnPause.setToolTip('Pause') # Speed Slider lblSlow = QLabel("Slow", self) lblSlow.setGeometry(QtCore.QRect(65, 400, 25, 25)) self.slSpeed = QSlider(QtCore.Qt.Horizontal, parent=self) self.slSpeed.setGeometry(QtCore.QRect(96, 400, 200, 25)) self.slSpeed.setMinimum(-10) self.slSpeed.setMaximum(10) self.slSpeed.setValue(0) self.slSpeed.setTickPosition(QSlider.TicksBelow) self.slSpeed.setTickInterval(1) self.slSpeed.setToolTip('Change tick speed.') lblFast = QLabel("Fast", self) lblFast.setGeometry(QtCore.QRect(305, 400, 25, 25)) # Color Selection group = QGroupBox("Change Colors", self) grid = QGridLayout() self.btnAliveColor = QPushButton("Alive...", self) self.btnAliveColor.setToolTip('Change color of alive cells.') self.btnDeadColor = QPushButton("Dead...", self) self.btnDeadColor.setToolTip('Change color of dead cells.') grid.addWidget(self.btnAliveColor, 0, 0) grid.addWidget(self.btnDeadColor, 0, 1) group.setLayout(grid) group.setGeometry(QtCore.QRect(35, 435, 325, 60)) # Starting Conditions group = QGroupBox("Starting Conditions", self) grid = QGridLayout() self.btnPulsar = QPushButton("Pulsar", self) self.btnPulsar.setToolTip("Change to 'Pulsar' initial state.") self.btnPenta = QPushButton("Penta-Decathalon", self) self.btnPenta.setToolTip("Change to 'Penta-Decathalon' initial state.") self.btnGosper = QPushButton("Gosper Glider Gun", self) self.btnGosper.setToolTip("Change to 'Gosper Glider Gun' " + "initial state.") grid.addWidget(self.btnPulsar, 0, 0) grid.addWidget(self.btnPenta, 0, 1) grid.addWidget(self.btnGosper, 0, 2) group.setLayout(grid) group.setGeometry(QtCore.QRect(35, 500, 325, 60)) # Reset Button self.btnReset = QPushButton('Reset', self) self.btnReset.setGeometry(QtCore.QRect(155, 565, 90, 25)) self.btnReset.setToolTip("Reset program to a random initial state.") self.show() self.btnStart.clicked.connect(self.onClickStart) self.btnPause.clicked.connect(self.onClickPause) self.slSpeed.valueChanged.connect(self.onSpeedChange) self.btnReset.clicked.connect(self.onClickReset) self.btnAliveColor.clicked.connect(self.onClickAliveColor) self.btnDeadColor.clicked.connect(self.onClickDeadColor) self.btnPulsar.clicked.connect(self.onClickPulsar) self.btnPenta.clicked.connect(self.onClickPenta) self.btnGosper.clicked.connect(self.onClickGosper)
class WindowPlot(QMainWindow): def __init__(self, parent=None): pg.setConfigOption('background', 'w') #before loading widget super(WindowPlot, self).__init__(parent) self.RNDbtn = False self.data = [] #np.random.normal(size=100) self.Xtime = [] self.refreshInterval = 1000 # default refresh plot every 1s self.timer = pg.QtCore.QTimer() self.errReadEvent = '' # holds error history self.counterTest = 0 self.wid = QtGui.QWidget(self) self.setCentralWidget(self.wid) vbox = QVBoxLayout() self.createLayout1() vbox.addWidget(self.groupBoxPlot) vbox.addWidget(self.groupBoxData) self.wid.setLayout(vbox) def createLayout1(self): vboxlayoutPlot = QVBoxLayout() vboxlayoutData = QVBoxLayout() self.groupBoxPlot = QGroupBox("Plotting") self.groupBoxData = QGroupBox("Data") self.create_plot() vboxlayoutPlot.addLayout(self.layout) self.gridPlot = QGridLayout() self.gridData = QGridLayout() self.slider = QSlider(QTC.Horizontal) self.slider.setFocusPolicy(QTC.StrongFocus) self.slider.setTickPosition(QSlider.TicksBothSides) self.slider.setTickInterval(1) self.slider.setSingleStep(1) self.slider.setMaximum(10) self.slider.setMinimum(0) # self.slider.valueChanged.connect(self.SliderVal) self.slider.setValue(7) self.cb = QtWidgets.QComboBox() # self.cb.addItem("10") self.cb.addItems(["5", "2", "1"]) self.cb.setCurrentIndex(2) self.cb.currentIndexChanged.connect(self.ComboInterval) self.Refr = QHBoxLayout() self.labelInterval = QLabel() self.labelInterval.setText("Refresh rate (s)") self.Refr.addWidget(self.labelInterval) self.Refr.addWidget(self.cb) # Error box START self.hboxErrSourceDt = QHBoxLayout() self.ErrorGroup = QGroupBox("Errors") self.vboxErrBox = QVBoxLayout() self.hboxErrLEDLBL = QHBoxLayout() self.hboxErrorEvents = QHBoxLayout() self.hboxErrorEvents.setSizeConstraint(QLayout.SetFixedSize) self.LEDError = QPushButton() # used as error LED indicator self.LEDError.setEnabled(False) self.LEDError.setMaximumHeight(15) self.LEDError.setMaximumWidth(15) self.labelErrorRead = QLabel() self.labelErrorRead.setText("Error reading data") self.label_ErrorReadEvents = QLabel() self.label_ErrorReadEvents.setFont(QtGui.QFont("Sanserif", 10)) self.label_ErrorReadEvents.setMinimumWidth(200) scrollErrors = QScrollArea() scrollErrors.setWidget(self.label_ErrorReadEvents) scrollErrors.setWidgetResizable(True) # scrollErrors.setMaximumHeight(80) scrollErrors.setMinimumWidth(200) self.hboxErrLEDLBL.addWidget(self.LEDError) self.hboxErrLEDLBL.addWidget(self.labelErrorRead) self.vboxErrBox.addLayout(self.hboxErrLEDLBL) self.vboxErrBox.addWidget(scrollErrors) self.ErrorGroup.setLayout(self.vboxErrBox) self.cbDataSource = QtWidgets.QComboBox() # self.cb.addItem("10") self.cbDataSource.addItems( ["Random generated test Data", "Remote data"]) self.cbDataSource.setCurrentIndex(1) self.hboxErrSourceDt.addWidget(self.ErrorGroup) self.hboxErrSourceDt.addWidget(self.cbDataSource) # Error box END self.GetDataBtn = QPushButton("Start Plot") self.GetDataBtn.clicked.connect(self.ticker) self.GetDataBtn.setMinimumHeight(50) self.GetDataBtn.setMinimumWidth(180) self.gridPlot.addWidget(self.slider, 0, 0) self.gridPlot.addLayout(self.Refr, 1, 0) self.gridData.addLayout(self.hboxErrSourceDt, 0, 0) self.gridData.addWidget(self.GetDataBtn, 0, 1) vboxlayoutPlot.addLayout(self.gridPlot) self.groupBoxPlot.setLayout(vboxlayoutPlot) vboxlayoutData.addLayout(self.gridData) self.groupBoxData.setLayout(vboxlayoutData) # def SliderVal(self): # print(self.slider.value()) def ComboInterval(self): self.refreshInterval = int(self.cb.currentText()) * 1000 if self.timer.isActive(): self.timer.stop() self.timer.start(self.refreshInterval) def create_plot(self): self.stream_scroll = pg.PlotWidget( title='Stream Monitor', labels={'left': 'Channel'}, axisItems={'bottom': TimeAxisItem(orientation='bottom')}) self.stream_scroll.setYRange(-4, 4, padding=.01) # self.stream_scroll.setXRange(0,100, padding=.01) self.stream_scroll.setXRange(timestamp(), timestamp() + 100) self.layout = QtGui.QGridLayout() self.stream_scroll.plotItem.showGrid(True, True, .5) self.layout.addWidget(self.stream_scroll, 0, 0) C = pg.hsvColor(.7, alpha=.5) self.pen = pg.mkPen(color=C, width=1) self.curve = self.stream_scroll.plot(pen=self.pen) def update1(self): # global data if len(self.data) > 100: self.data[:-1] = self.data[ 1:] # shift data in the array one, see also np.pull if self.cbDataSource.currentIndex() == 0: self.data[-1] = np.random.rand() # .normal() else: self.data[-1] = self.FiledataConvert() self.Xtime[:-1] = self.Xtime[1:] self.Xtime[-1] = timestamp() # int(round(time.time()*1000))+100 else: if self.cbDataSource.currentIndex() == 0: self.data.append(np.random.rand()) else: self.data.append(self.FiledataConvert()) self.Xtime.append(timestamp()) X = self.Xtime # Y=np.sin(np.arange(points)/points*3*np.pi+time.time()) # draw sin wave Y = self.data # np.random.rand(100) self.curve.setData(X, Y) def FiledataConvert(self): f = open("output1.txt", "r") a = f.read() f.close() try: a = round(int(a) / 204, 3) self.LEDError.setStyleSheet("background-color: blue") except Exception as err: datetimeObj = datetime.now() a = 0 self.LEDError.setStyleSheet("background-color: red") print(datetimeObj) print(traceback.format_exc()) # display error self.errReadEvent = self.errReadEvent + 'Error reading Data at:' + str( datetimeObj) + '\n' self.label_ErrorReadEvents.setText(self.errReadEvent) # print(sys.exc_info()[0]) # display error return a def ticker(self): if self.RNDbtn == False: self.timer = pg.QtCore.QTimer() self.timer.timeout.connect(self.update1) self.timer.start(self.refreshInterval) self.RNDbtn = True self.GetDataBtn.setStyleSheet("background-color: green") self.GetDataBtn.setText("Disconnect") else: self.timer.stop() self.RNDbtn = False self.GetDataBtn.setStyleSheet("background-color: red") self.GetDataBtn.setText("Connect")
def initUI(self): self.setGeometry(350, 200, 600, 400) self.setWindowTitle('Password generator') # title of the window self.title = QtWidgets.QLabel('Times', self) self.title.setFont(QFont('Times', 20)) self.title.setText('Password Generator') self.title.move(180, 10) self.title.resize(250, 80) # atturtuibes of the password # length of the password self.length_of_password = QtWidgets.QLineEdit(self) self.length_of_password.setDisabled(True) self.length_of_password.setText('0') self.length_of_password.resize(150, 40) self.length_of_password.move(40, 115) self.add_length = QtWidgets.QPushButton(self) self.add_length.setText("A") self.add_length.move(170, 115) self.add_length.resize(20, 20) self.add_length.setObjectName("length_of_password") self.add_length.clicked.connect(self.add_or_sub) self.remove_length = QtWidgets.QPushButton(self) self.remove_length.setText("S") self.remove_length.move(170, 135) self.remove_length.resize(20, 20) self.remove_length.setObjectName("length_of_password") self.remove_length.clicked.connect(self.add_or_sub) self.len_of_pass = QtWidgets.QLabel(self) self.len_of_pass.setText('Length of password') self.len_of_pass.setFont(QFont('Times', 10)) self.len_of_pass.move(40, 80) self.len_of_pass.resize(250, 40) # password add special characters self.add_special = QtWidgets.QLabel(self) self.add_special.setText( 'Add special characters. (^ < > , . \' \" ` ~)') self.add_special.setFont(QFont('Times', 10)) self.add_special.move(40, 150) self.add_special.resize(250, 40) self.checkbox1 = QCheckBox(self) self.checkbox1.move(300, 165) # password adds capital letters self.add_caps = QtWidgets.QLabel(self) self.add_caps.setText('Add capital letters. (A B C D)') self.add_caps.setFont(QFont('Times', 10)) self.add_caps.move(40, 180) self.add_caps.resize(250, 40) self.checkbox2 = QCheckBox(self) self.checkbox2.move(300, 192) # password add letters self.add_letters = QtWidgets.QLabel(self) self.add_letters.setText('Add letters. (a b c d)') self.add_letters.setFont(QFont('Times', 10)) self.add_letters.move(40, 210) self.add_letters.resize(250, 40) self.checkbox3 = QCheckBox(self) self.checkbox3.move(300, 219) self.add_numbers = QtWidgets.QLabel(self) self.add_numbers.setText('Add numbers. (1 2 3 4)') self.add_numbers.setFont(QFont('Times', 10)) self.add_numbers.move(40, 240) self.add_numbers.resize(250, 40) self.checkbox4 = QCheckBox(self) self.checkbox4.move(300, 246) # password add math symbols self.add_math_symbols = QtWidgets.QLabel(self) self.add_math_symbols.setText('Add math symbols. (+ - = /)') self.add_math_symbols.setFont(QFont('Times', 10)) self.add_math_symbols.move(40, 270) self.add_math_symbols.resize(250, 40) self.checkbox5 = QCheckBox(self) self.checkbox5.move(300, 280) # amount of passwords self.amount_of_passwords = QtWidgets.QLineEdit(self) self.amount_of_passwords.setDisabled(True) self.amount_of_passwords.setText('0') self.amount_of_passwords.resize(150, 40) self.amount_of_passwords.move(375, 115) self.add_passwords = QtWidgets.QPushButton(self) self.add_passwords.setText("A") self.add_passwords.move(505, 115) self.add_passwords.resize(20, 20) self.add_passwords.clicked.connect(self.add_or_sub) self.remove_passwords = QtWidgets.QPushButton(self) self.remove_passwords.setText("S") self.remove_passwords.move(505, 135) self.remove_passwords.resize(20, 20) self.remove_passwords.clicked.connect(self.add_or_sub) self.amount_of_pass = QtWidgets.QLabel(self) self.amount_of_pass.setText('Add amount of passwords') self.amount_of_pass.setFont(QFont('Times', 10)) self.amount_of_pass.move(375, 80) self.amount_of_pass.resize(250, 40) # submit password with attrubites self.submit_password = QtWidgets.QPushButton(self) self.submit_password.setText("Get Passwords") self.submit_password.move(375, 165) self.submit_password.resize(150, 40) self.submit_password.clicked.connect(self.submit) #slide down for information self.slider = QSlider(Qt.Vertical, self) self.slider.valueChanged.connect(self.updateLabel) self.slider.resize(30, 75) self.slider.move(515, 250) self.slider.setInvertedAppearance(True) self.slider.setDisabled(True) #display passwords self.display_passwords = QtWidgets.QLabel(self) self.display_passwords.setFont(QFont('Times', 10)) self.display_passwords.setText('') self.display_passwords.move(375, 230)
class Mainwindow(QMainWindow): def __init__(self): super(mainwindow, self).__init__() self.initUI() self.password_attributes = [] self.numbers = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", ] self.math_symbols = [ "*", "%", "(", ")", "/", "+", "=", "-", ">", "<", ] self.letters = [ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z' ] self.caps_letters = [letter.upper() for letter in self.letters] self.speical_chacathers = [ "!", "`", "~", "@", "#", "$", "&", "_", "}", "{", "\"", "\'", ",", "." ] self.passwords = [] def initUI(self): self.setGeometry(350, 200, 600, 400) self.setWindowTitle('Password generator') # title of the window self.title = QtWidgets.QLabel('Times', self) self.title.setFont(QFont('Times', 20)) self.title.setText('Password Generator') self.title.move(180, 10) self.title.resize(250, 80) # atturtuibes of the password # length of the password self.length_of_password = QtWidgets.QLineEdit(self) self.length_of_password.setDisabled(True) self.length_of_password.setText('0') self.length_of_password.resize(150, 40) self.length_of_password.move(40, 115) self.add_length = QtWidgets.QPushButton(self) self.add_length.setText("A") self.add_length.move(170, 115) self.add_length.resize(20, 20) self.add_length.setObjectName("length_of_password") self.add_length.clicked.connect(self.add_or_sub) self.remove_length = QtWidgets.QPushButton(self) self.remove_length.setText("S") self.remove_length.move(170, 135) self.remove_length.resize(20, 20) self.remove_length.setObjectName("length_of_password") self.remove_length.clicked.connect(self.add_or_sub) self.len_of_pass = QtWidgets.QLabel(self) self.len_of_pass.setText('Length of password') self.len_of_pass.setFont(QFont('Times', 10)) self.len_of_pass.move(40, 80) self.len_of_pass.resize(250, 40) # password add special characters self.add_special = QtWidgets.QLabel(self) self.add_special.setText( 'Add special characters. (^ < > , . \' \" ` ~)') self.add_special.setFont(QFont('Times', 10)) self.add_special.move(40, 150) self.add_special.resize(250, 40) self.checkbox1 = QCheckBox(self) self.checkbox1.move(300, 165) # password adds capital letters self.add_caps = QtWidgets.QLabel(self) self.add_caps.setText('Add capital letters. (A B C D)') self.add_caps.setFont(QFont('Times', 10)) self.add_caps.move(40, 180) self.add_caps.resize(250, 40) self.checkbox2 = QCheckBox(self) self.checkbox2.move(300, 192) # password add letters self.add_letters = QtWidgets.QLabel(self) self.add_letters.setText('Add letters. (a b c d)') self.add_letters.setFont(QFont('Times', 10)) self.add_letters.move(40, 210) self.add_letters.resize(250, 40) self.checkbox3 = QCheckBox(self) self.checkbox3.move(300, 219) self.add_numbers = QtWidgets.QLabel(self) self.add_numbers.setText('Add numbers. (1 2 3 4)') self.add_numbers.setFont(QFont('Times', 10)) self.add_numbers.move(40, 240) self.add_numbers.resize(250, 40) self.checkbox4 = QCheckBox(self) self.checkbox4.move(300, 246) # password add math symbols self.add_math_symbols = QtWidgets.QLabel(self) self.add_math_symbols.setText('Add math symbols. (+ - = /)') self.add_math_symbols.setFont(QFont('Times', 10)) self.add_math_symbols.move(40, 270) self.add_math_symbols.resize(250, 40) self.checkbox5 = QCheckBox(self) self.checkbox5.move(300, 280) # amount of passwords self.amount_of_passwords = QtWidgets.QLineEdit(self) self.amount_of_passwords.setDisabled(True) self.amount_of_passwords.setText('0') self.amount_of_passwords.resize(150, 40) self.amount_of_passwords.move(375, 115) self.add_passwords = QtWidgets.QPushButton(self) self.add_passwords.setText("A") self.add_passwords.move(505, 115) self.add_passwords.resize(20, 20) self.add_passwords.clicked.connect(self.add_or_sub) self.remove_passwords = QtWidgets.QPushButton(self) self.remove_passwords.setText("S") self.remove_passwords.move(505, 135) self.remove_passwords.resize(20, 20) self.remove_passwords.clicked.connect(self.add_or_sub) self.amount_of_pass = QtWidgets.QLabel(self) self.amount_of_pass.setText('Add amount of passwords') self.amount_of_pass.setFont(QFont('Times', 10)) self.amount_of_pass.move(375, 80) self.amount_of_pass.resize(250, 40) # submit password with attrubites self.submit_password = QtWidgets.QPushButton(self) self.submit_password.setText("Get Passwords") self.submit_password.move(375, 165) self.submit_password.resize(150, 40) self.submit_password.clicked.connect(self.submit) #slide down for information self.slider = QSlider(Qt.Vertical, self) self.slider.valueChanged.connect(self.updateLabel) self.slider.resize(30, 75) self.slider.move(515, 250) self.slider.setInvertedAppearance(True) self.slider.setDisabled(True) #display passwords self.display_passwords = QtWidgets.QLabel(self) self.display_passwords.setFont(QFont('Times', 10)) self.display_passwords.setText('') self.display_passwords.move(375, 230) def add_or_sub(self): sender = self.sender() if sender.objectName() == "length_of_password": if sender.text() == self.remove_passwords.text(): if int(self.length_of_password.text()) != 0: self.length_of_password.setText( str(int(self.length_of_password.text()) - 1)) else: self.length_of_password.setText( str(int(self.length_of_password.text()) + 1)) else: if sender.text() == self.remove_passwords.text(): if int(self.amount_of_passwords.text()) != 0: self.amount_of_passwords.setText( str(int(self.amount_of_passwords.text()) - 1)) else: self.amount_of_passwords.setText( str(int(self.amount_of_passwords.text()) + 1)) def submit(self): if int(self.length_of_password.text()) != 0 and int( self.amount_of_passwords.text()) != 0: minmal_len = 0 amount_of_passwords = int(self.amount_of_passwords.text()) lenght_of_password = int(self.length_of_password.text()) if self.checkbox1.isChecked() == True: self.password_attributes.append(self.speical_chacathers) minmal_len += 1 if self.checkbox2.isChecked() == True: self.password_attributes.append(self.caps_letters) minmal_len += 1 if self.checkbox3.isChecked() == True: self.password_attributes.append(self.letters) minmal_len += 1 if self.checkbox4.isChecked() == True: self.password_attributes.append(self.numbers) minmal_len += 1 if self.checkbox5.isChecked() == True: self.password_attributes.append(self.math_symbols) minmal_len += 1 if int(self.length_of_password.text()) < minmal_len: QMessageBox.about( self, "Problem", "Your password is not long enough for the attributes that you want" ) self.password_attributes = [] if minmal_len == 0: QMessageBox.about(self, "Problem", "Make sure you have atleast one attribute") else: for passwords in range(0, amount_of_passwords): password = '' must_have = [x for x in range(0, minmal_len)] random.shuffle(must_have) for letters in range(0, lenght_of_password): if len(must_have) != 0: password += random.choice( self.password_attributes[must_have[0]]) must_have.pop(0) else: password += random.choice( random.choice(self.password_attributes)) password = list(password) random.shuffle(password) self.passwords.append("".join(password)) print(self.passwords) self.slider.setDisabled(False) self.slider.setRange(0, len(self.passwords)) self.display_passwords.setText('\n'.join(self.passwords[0:5])) self.display_passwords.adjustSize() if len(self.passwords) <= 5: self.slider.hide() else: self.slider.setRange(5, len(self.passwords)) else: QMessageBox.about( self, "Problem", "Make sure you have a password that is atleast 1 character and atleast 1 password" ) def updateLabel(self, value): value = self.slider.value() self.display_passwords.setText('\n'.join(self.passwords[value - 5:value]))
def createLayout1(self): vboxlayoutPlot = QVBoxLayout() vboxlayoutData = QVBoxLayout() self.groupBoxPlot = QGroupBox("Plotting") self.groupBoxData = QGroupBox("Data") self.create_plot() vboxlayoutPlot.addLayout(self.layout) self.gridPlot = QGridLayout() self.gridData = QGridLayout() self.slider = QSlider(QTC.Horizontal) self.slider.setFocusPolicy(QTC.StrongFocus) self.slider.setTickPosition(QSlider.TicksBothSides) self.slider.setTickInterval(1) self.slider.setSingleStep(1) self.slider.setMaximum(10) self.slider.setMinimum(0) # self.slider.valueChanged.connect(self.SliderVal) self.slider.setValue(7) self.cb = QtWidgets.QComboBox() # self.cb.addItem("10") self.cb.addItems(["5", "2", "1"]) self.cb.setCurrentIndex(2) self.cb.currentIndexChanged.connect(self.ComboInterval) self.Refr = QHBoxLayout() self.labelInterval = QLabel() self.labelInterval.setText("Refresh rate (s)") self.Refr.addWidget(self.labelInterval) self.Refr.addWidget(self.cb) # Error box START self.hboxErrSourceDt = QHBoxLayout() self.ErrorGroup = QGroupBox("Errors") self.vboxErrBox = QVBoxLayout() self.hboxErrLEDLBL = QHBoxLayout() self.hboxErrorEvents = QHBoxLayout() self.hboxErrorEvents.setSizeConstraint(QLayout.SetFixedSize) self.LEDError = QPushButton() # used as error LED indicator self.LEDError.setEnabled(False) self.LEDError.setMaximumHeight(15) self.LEDError.setMaximumWidth(15) self.labelErrorRead = QLabel() self.labelErrorRead.setText("Error reading data") self.label_ErrorReadEvents = QLabel() self.label_ErrorReadEvents.setFont(QtGui.QFont("Sanserif", 10)) self.label_ErrorReadEvents.setMinimumWidth(200) scrollErrors = QScrollArea() scrollErrors.setWidget(self.label_ErrorReadEvents) scrollErrors.setWidgetResizable(True) # scrollErrors.setMaximumHeight(80) scrollErrors.setMinimumWidth(200) self.hboxErrLEDLBL.addWidget(self.LEDError) self.hboxErrLEDLBL.addWidget(self.labelErrorRead) self.vboxErrBox.addLayout(self.hboxErrLEDLBL) self.vboxErrBox.addWidget(scrollErrors) self.ErrorGroup.setLayout(self.vboxErrBox) self.cbDataSource = QtWidgets.QComboBox() # self.cb.addItem("10") self.cbDataSource.addItems( ["Random generated test Data", "Remote data"]) self.cbDataSource.setCurrentIndex(1) self.hboxErrSourceDt.addWidget(self.ErrorGroup) self.hboxErrSourceDt.addWidget(self.cbDataSource) # Error box END self.GetDataBtn = QPushButton("Start Plot") self.GetDataBtn.clicked.connect(self.ticker) self.GetDataBtn.setMinimumHeight(50) self.GetDataBtn.setMinimumWidth(180) self.gridPlot.addWidget(self.slider, 0, 0) self.gridPlot.addLayout(self.Refr, 1, 0) self.gridData.addLayout(self.hboxErrSourceDt, 0, 0) self.gridData.addWidget(self.GetDataBtn, 0, 1) vboxlayoutPlot.addLayout(self.gridPlot) self.groupBoxPlot.setLayout(vboxlayoutPlot) vboxlayoutData.addLayout(self.gridData) self.groupBoxData.setLayout(vboxlayoutData)