class IntEditor(QWidget):
def __init__(self, minval, maxval, stepsize=1, parent=None):
super(IntEditor, self).__init__(parent)
# Editfield
self.edit = QSpinBox(self)
self.edit.setKeyboardTracking(False)
self.edit.setRange(minval, maxval)
self.edit.setSingleStep(stepsize)
self.edit.setMinimumWidth(70)
# Slider
self.slider = QSlider(orientation=Qt.Vertical, parent=self)
self.slider.setRange(minval, maxval)
self.slider.setSingleStep(stepsize)
self.slider.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Expanding)
# Ticks
q_ticks = QSlider.TicksBelow
self.slider.setTickPosition(q_ticks)
tick_amount = 6
tick_interval = int(np.floor((maxval - minval) / tick_amount))
self.slider.setTickInterval(tick_interval)
# ...labels
font = QFont()
font.setPointSize(8)
tick_str1 = QLabel('{:d}'.format(minval), self)
tick_str2 = QLabel('{:d}'.format(maxval), self)
tick_str1.setFont(font)
tick_str2.setFont(font)
slider_tick_layout = QGridLayout()
tick_str1.setAlignment(Qt.AlignBottom | Qt.AlignLeft)
tick_str2.setAlignment(Qt.AlignTop | Qt.AlignLeft)
slider_tick_layout.addWidget(self.slider, 0, 0, tick_amount, 1)
slider_tick_layout.addWidget(tick_str2, 0, 1, 1, 1)
slider_tick_layout.addWidget(tick_str1, tick_amount - 1, 1, 1, 1)
# Layout
layout = QVBoxLayout()
layout.addLayout(slider_tick_layout)
layout.addWidget(self.edit)
self.setLayout(layout)
# Signals and slots
self.edit.valueChanged.connect(self.slider.setValue)
self.slider.valueChanged.connect(self.edit.setValue)
def initializePage(self):
self.parent_wizard.next_button.setDisabled(True)
# grid
# |----> groupbox 1 (for choice 1)
# |----> vertical_layout 1
# |----> inner_grid 1 (for criteria 1)
# |----> label1
# |----> value_spin_box 1
# |----> inner_grid 2 (for criteria 2)
# |----> label2
# |----> rating_spin_box 2
# |----> groupbox 2 (for choice 2)
# |-...
# TODO: consider extracting out common code with
# AbstractSliderPage
for choice in self.parent_wizard.main_parent.matrix.df.index[1:]:
groupbox = QGroupBox(choice)
vertical_layout = QVBoxLayout(groupbox)
self.grid.addWidget(groupbox)
self.spin_boxes[choice] = []
self.sliders[choice] = []
for row, criterion in enumerate(
self.parent_wizard.main_parent.matrix.criteria):
rating_spin_box = QSpinBox()
rating_spin_box.setRange(0, 10)
self.spin_boxes[choice].append(rating_spin_box)
slider = QSlider(Qt.Orientation.Horizontal)
slider.setTickPosition(QSlider.TicksBelow)
slider.setMaximum(10)
slider.setPageStep(1)
slider.setTracking(True)
self.sliders[choice].append(slider)
cb = partial(self.spin_box_changed, row, choice, criterion)
rating_spin_box.valueChanged.connect(cb)
cb = partial(self.slider_changed, row, choice, criterion)
slider.valueChanged.connect(cb)
spin_box_and_slider = QHBoxLayout()
spin_box_and_slider.addWidget(rating_spin_box)
spin_box_and_slider.addWidget(slider)
inner_form = QFormLayout()
inner_form.addRow(QLabel(criterion), spin_box_and_slider)
vertical_layout.addLayout(inner_form)
def __init__(self, parent, header):
super().__init__(parent)
self.header = header
self.header_index, _ = self.parent().table.model_c.metadata_c.get_header_meta(self.header["name"])
self.setStyleSheet(styles.filter_line_edit)
# LAYOUTS
self.grid = QGridLayout()
self.v_layout = QVBoxLayout()
self.h_layout = QHBoxLayout()
# FIELDS
self.header_label = QLabel(f'{self.header["name"]} : ', self)
self.header_label.setFixedWidth(100)
self.input = QLineEdit(self)
self.input.setMaxLength(self.header["data_type"]["max_value"])
self.input.setPlaceholderText(str(self.parent().table.model_c.get_common_values(header["name"])))
self.exact = QCheckBox("Exact", self)
self.exact.setToolTip(f"Value in '{self.header['name']}' must be exacly '{self.input.text()}'")
self.exact.stateChanged.connect(self.exact_checked)
# SLIDER SET UP
self.slider = None
if self.header["data_type"]["type"] == "int":
self.slider = QSlider(Qt.Horizontal, self)
(self.slider.min_v, self.slider.max_v) = self.parent().table.get_min_max(self.header["name"])
self.slider.setMinimum(self.slider.min_v)
self.slider.setMaximum(self.slider.max_v)
self.slider.valueChanged.connect(self.slider_value_changed)
self.slider.hint = QLabel(f'{self.slider.minimum()} - {self.slider.value()}', self)
# SET UP
self.h_layout.addWidget(self.input)
self.h_layout.addWidget(self.exact)
self.v_layout.addLayout(self.h_layout)
if self.slider is not None:
self.v_layout.addWidget(self.slider.hint)
self.v_layout.addWidget(self.slider)
self.grid.addWidget(self.header_label, 0, 0)
self.grid.addLayout(self.v_layout, 0, 1)
self.setLayout(self.grid)
def __init__(self):
QMainWindow.__init__(self)
self.setGeometry(300, 300, 300, 300)
self.setFixedSize(300, 300)
self.setWindowTitle('libmapper device gui example')
blurb = QLabel(
'These sliders will be dynamically labeled with the name of destination signals to which they are connected.',
self)
blurb.setGeometry(5, 0, 290, 50)
blurb.setWordWrap(True)
self.labels = []
self.sliders = []
for i in range(numsliders):
self.sliders.append(QSlider(Qt.Orientation.Horizontal, self))
self.sliders[i].setRange(0, 100)
self.sliders[i].setGeometry(5, 100 + i * 75, 290, 20)
self.labels.append(QLabel('slider%i' % i, self))
self.labels[i].setGeometry(5, 75 + i * 75, 290, 15)
self.sliders[0].valueChanged.connect(
lambda x: sigs[0].set_value(x * 0.01))
self.sliders[1].valueChanged.connect(
lambda x: sigs[1].set_value(x * 0.01))
self.sliders[2].valueChanged.connect(
lambda x: sigs[2].set_value(x * 0.01))
self.timer = QBasicTimer()
self.timer.start(10, self)
def __init__(self):
QWidget.__init__(self)
self.setFixedSize(500, 300)
self.setWindowTitle('IHM')
self.layout = QHBoxLayout()
self.progressBar = QProgressBar()
self.progressBar.setValue(50)
self.slider = QSlider()
self.slider.setValue(50)
self.layout.addWidget(self.progressBar)
self.layout.addWidget(self.slider)
self.slider.valueChanged.connect(self.OnSlider)
self.setLayout(self.layout)
def __init__(self):
QWidget.__init__(self)
self.setWindowTitle('IHM')
self.setMinimumSize(250, 100)
self.main_layout = QHBoxLayout()
self.setLayout(self.main_layout)
self.progressBar = QProgressBar()
self.slider = QSlider()
self.slider.valueChanged.connect(self.updateValue)
self.main_layout.addWidget(self.progressBar)
self.main_layout.addWidget(self.slider)
self.show()
def __init__(self, parent=None):
super(fenetrePrincipale, self).__init__(parent)
self.setMinimumSize(400, 400)
self.compteur = monPainter()
self.slider = QSlider(QtCore.Qt.Horizontal)
self.slider.setRange(1, 1000)
layout = QVBoxLayout()
layout.addWidget(self.compteur)
layout.addWidget(self.slider)
# set dialog layout
self.setLayout(layout)
self.slider.valueChanged.connect(self.compteur.modifTimer)
def __init__(self):
super(MainWindow, self).__init__()
self.setupUi(self)
threadpool = QThreadPool.globalInstance()
self.plot_worker = PlotWorker()
self.plot_worker.signals.update_layers.connect(self.layers_update)
self.plot_worker.signals.update_status.connect(self.status_update)
self.plot_worker.signals.update_progress.connect(self.progress_update)
self.plot_worker.signals.ready.connect(self.plot_ready)
threadpool.start(self.plot_worker)
print("Initialising Plot Server")
self.plot_worker.signals.init.emit('OSM')
self.listWidget.setEnabled(True)
self.listWidget.setDragDropMode(QAbstractItemView.InternalMove)
self.listWidget.setAcceptDrops(True)
self.listWidget.itemDropped.connect(self.layer_reorder)
self.timeSlider = QSlider(Qt.Horizontal)
self.timeSlider.setObjectName(u"timeSlider")
self.timeSlider.setGeometry(QRect(760, 0, 441, 22))
self.timeSlider.setMaximum(167)
self.timeSlider.setPageStep(3)
self.timeSlider.setTickPosition(QSlider.TicksAbove)
self.timeSlider.setTickInterval(12)
self.toolBar.addWidget(self.timeSlider)
self.timeSliderLabel = QLabel("Time of Week")
self.timeSliderLabel.setObjectName(u"timeSliderLabel")
self.timeSliderLabel.setGeometry(QRect(590, 0, 161, 20))
self.toolBar.addWidget(self.timeSliderLabel)
self.timeSlider.valueChanged.connect(self.time_changed)
self.addLayerButton.clicked.connect(self.layer_add)
self.generateButton.clicked.connect(
self.plot_worker.signals.generate.emit)
self.plotWebview.resize.connect(self.resize_plot)
self.actionRasterise.triggered.connect(self.menu_config_rasterise)
# self.actionImport.triggered.connect(self.menu_file_import)
self.actionExport.triggered.connect(self.menu_file_export)
self.actionAbout_Static_Sources.triggered.connect(
self.menu_about_static_sources)
self.actionAbout_App.triggered.connect(self.menu_about_app)
self.actionAdd_Aircraft.triggered.connect(self.add_aircraft)
def __init__(self):
QWidget.__init__(self)
self.layout = QHBoxLayout()
self.setWindowTitle("IHM")
self.bar = QProgressBar(self)
self.slider = QSlider(self)
self.slider.setMinimum(0)
self.slider.setMaximum(100)
self.slider.setValue(20)
self.slider.valueChanged.connect(self.valuechange)
self.layout.addWidget(self.bar)
self.layout.addWidget(self.slider)
self.setLayout(self.layout)
def __init__(self, parent=None): # 初始化，无父类
super().__init__(parent)
self.lcd_number = QLCDNumber() # 创建一个lcd数字显示器对象
self.slider = QSlider(Qt.Horizontal) # 创建滑动条，水平显示
self.layout = QVBoxLayout() # 两元素使用垂直布局（上下排列）
self.layout.addWidget(self.lcd_number) # 将lcd_num对象加入
self.layout.addWidget(self.slider) # 将slider对象加入
self.setLayout(self.layout)
self.setFixedSize(120, 100) # 设置整个控件大小
self.lcd_number.setDigitCount(2) # 设置lcd显示器最多显示两位数字
self.slider.setRange(0, 99) # 设置可调节的范围
self.slider.valueChanged.connect(
self.lcd_number.display) # 滑动条的值修改，连接到lcd的显示值
def __init__(self, close_event_callback: Event):
super(MainWindow, self).__init__()
self.close_event_callback = close_event_callback
self.resize(700, 900)
# main_wgt
main_wgt = QWidget()
self.setCentralWidget(main_wgt)
self.setWindowTitle("RS Companion")
# main_window/main_wgt <- main_grid
grid = QGridLayout()
main_wgt.setLayout(grid)
# mdi
self.mdi_win = mdi_win.MDIWidget()
mdi = QMdiArea()
# slider
slider = QSlider()
slider.setOrientation(Qt.Horizontal)
# main_window/main_wgt-main_grid <- gb_control_bar
grid.addWidget(self.set_controls(), 0, 0)
grid.addWidget(self.set_key_flag(), 0, 1)
grid.addWidget(self.set_notes(), 0, 2)
grid.addWidget(self.set_information(), 0, 4)
grid.addItem(
QSpacerItem(300, 0, QSizePolicy.Minimum, QSizePolicy.Expanding), 0,
3)
grid.addWidget(mdi, 1, 0, 1, 5)
grid.addWidget(slider, 2, 0, 1, 5)
grid.setRowStretch(1, 1)
# menu
self.set_menu()
# QMDI subwindow
# sub = QMdiSubWindow()
# sub.resize(655, 515)
# self.mid_text = QLabel("Nothing yet...")
# self.mid_text.setText("what??")
# sub.setWidget(self.mid_text)
# sub.setWindowTitle("VOG COM32")
# sub.setWindowIcon(self.create_icon_by_color(QColor("transparent")))
mdi.addSubWindow(self.mdi_win)
def __init__(self, parent):
super().__init__(parent)
self.status = False
self.main_layout = QVBoxLayout(self)
self.first_row_layout = QHBoxLayout(self)
self.start_button = QPushButton(self)
self.start_button.setText("START")
self.first_row_layout.addWidget(self.start_button)
self.rpm_label = QLabel("0000 RPM",self)
self.first_row_layout.addWidget(self.rpm_label)
self.gear_label = QLabel("Gear: N", self)
self.first_row_layout.addWidget(self.gear_label)
self.speed_label = QLabel("000 Km/h", self)
self.first_row_layout.addWidget(self.speed_label)
self.stop_button = QPushButton(self)
self.stop_button.setText("STOP")
self.first_row_layout.addWidget(self.stop_button)
self.second_row_layout = QHBoxLayout(self)
self.throttle_label = QLabel("Throttle:", self)
self.second_row_layout.addWidget(self.throttle_label)
self.throttle_slider = QSlider(Qt.Horizontal)
self.throttle_slider.setMaximum(70)
self.throttle_slider.setMinimum(-30)
self.second_row_layout.addWidget(self.throttle_slider)
self.status_label = QLabel("Status: OFF", self)
self.second_row_layout.addWidget(self.status_label)
self.main_layout.addLayout(self.first_row_layout)
self.main_layout.addLayout(self.second_row_layout)
self.start_button.clicked.connect(self.thread_init)
self.stop_button.clicked.connect(self.process_stop)
self.stop_button.setDisabled(True)
class MenuSlider(QWidgetAction):
def __init__(self, text=""):
QWidgetAction.__init__(self, None)
self.widget = QWidget(None)
self.layout = QHBoxLayout()
self.slider = QSlider()
self.slider.setOrientation(Qt.Horizontal)
self.label = QLabel()
self.label.setText(text)
self.layout.addWidget(self.label)
self.layout.addWidget(self.slider)
self.widget.setLayout(self.layout)
self.setDefaultWidget(self.widget)
def connectvalueChanged(self, callback):
self.slider.valueChanged.connect(callback)
def value(self):
return self.slider.value()
def setMin(self, val):
self.slider.setMinimum(val)
def setMax(self, val):
self.slider.setMaximum(val)
class slideBar(QWidget):
changed = Signal(int)
def __init__(self,
label,
maxpos=180,
text=None,
input_width=50,
qtapp=None,
parent=None,
callback=None):
QWidget.__init__(self, parent)
self.parent = parent
self.__label = label
self.__maxpos = maxpos
self.input_width = input_width
self.callback = callback
self.__ipRegex = None
self.__text = text
self.gui_init()
def gui_init(self):
layout = QHBoxLayout()
self.setLayout(layout)
label = QLabel(self.__label, self)
layout.addWidget(label)
self.pos_sld = QSlider(Qt.Horizontal)
self.pos_sld.setMaximum(self.__maxpos)
self.pos_sld.setTickPosition(QSlider.TicksBothSides)
self.pos_sld.valueChanged[int].connect(self.onValueChanged)
self.pos_sld.setTickInterval(10)
self.pos_sld.setSingleStep(1)
layout.addWidget(self.pos_sld)
def onValueChanged(self, value):
self.changed.emit(value)
def setValue(self, value):
self.pos_sld.setValue(value)
def __init__(self, parent: QWidget = None):
super(FrmGaugeProgress, self).__init__(parent)
self.gauges: List[GaugeProgress] = []
layout = QHBoxLayout()
self.cboxPointerStyle = QComboBox()
self.cboxPointerStyle.clear()
self.cboxPointerStyle.addItems(
['圆形指示器', '指针指示器', '圆角指针指示器', '三角指示器'])
self.ckShowPointer = QCheckBox('显示指针')
self.ckShowValue = QCheckBox('显示值')
self.horizontalSlider = QSlider(Qt.Horizontal)
self.horizontalSlider.setMaximum(100)
layout.addWidget(self.ckShowPointer)
layout.addWidget(self.ckShowValue)
layout.addWidget(self.cboxPointerStyle)
layout.addWidget(self.horizontalSlider)
layout2 = QGridLayout()
self.gaugeProgress1 = GaugeProgress()
self.gaugeProgress2 = GaugeProgress()
self.gaugeProgress3 = GaugeProgress()
self.gaugeProgress4 = GaugeProgress()
self.gaugeProgress5 = GaugeProgress()
self.gaugeProgress6 = GaugeProgress()
layout2.addWidget(self.gaugeProgress1, 0, 0)
layout2.addWidget(self.gaugeProgress2, 0, 1)
layout2.addWidget(self.gaugeProgress3, 0, 2)
layout2.addWidget(self.gaugeProgress4, 1, 0)
layout2.addWidget(self.gaugeProgress5, 1, 1)
layout2.addWidget(self.gaugeProgress6, 1, 2)
layout3 = QVBoxLayout()
layout3.addLayout(layout2)
layout3.addLayout(layout)
self.setLayout(layout3)
self.initForm()
self.ckShowPointer.stateChanged.connect(
self.on_ckShowPointer_stateChanged)
self.ckShowValue.stateChanged.connect(
self.on_ckShowValue_stateChanged)
self.cboxPointerStyle.currentIndexChanged.connect(
self.on_cboxPointerStyle_currentIndexChanged)
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setFixedSize(1200, 920)
self.setWindowTitle("Vlasov Roman lr3")
# OpenGL widget
glWidgetW = 800
glWidgetH = 900
self.OpenGLWidget = OpenGLView()
self.OpenGLWidget.setFixedSize(glWidgetW, glWidgetH)
self.OpenGLWidget.setIterations(0)
# number of iterations
minIter = 0
maxIter = 6
self.iterationsLabel = QLabel("Number of iterations: ")
self.iterationsSpinBox = QSpinBox()
self.iterationsSpinBox.setMinimum(minIter)
self.iterationsSpinBox.setMaximum(maxIter)
self.iterationsSpinBox.valueChanged.connect(self.onSpinPointsChanged)
self.iterationsSlider = QSlider(QtCore.Qt.Horizontal)
self.iterationsSlider.setMinimum(minIter)
self.iterationsSlider.setMaximum(maxIter)
self.iterationsSlider.valueChanged.connect(self.onSliderPointsChanged)
self.iterationsMinLabel = QLabel("Min: %d" % minIter)
self.iterationsMinLabel.setFixedWidth(40)
self.iterationsMaxLabel = QLabel("Max: %d" % maxIter)
self.iterationsMaxLabel.setFixedWidth(60)
line1 = QFrame()
line1.setFrameShape(QFrame.HLine)
layoutAmount = QHBoxLayout()
layoutAmount.addWidget(self.iterationsMinLabel)
layoutAmount.addWidget(self.iterationsSpinBox)
layoutAmount.addWidget(self.iterationsMaxLabel)
# tools panel layout
layoutTools = QVBoxLayout()
layoutTools.addWidget(self.iterationsLabel)
layoutTools.addLayout(layoutAmount)
layoutTools.addWidget(self.iterationsSlider)
verticalSpacer = QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
layoutTools.addItem(verticalSpacer)
# window layout
layout = QHBoxLayout()
layout.addWidget(self.OpenGLWidget)
layout.addLayout(layoutTools)
self.setLayout(layout)
def __init__(self, minimum: float, maximum: float, initial: float,
divisor: int) -> None:
super().__init__()
slider = QSlider(Qt.Horizontal)
slider.setMinimum(int(minimum * divisor))
slider.setMaximum(int(maximum * divisor))
slider.setValue(initial)
self.spinner = FloatSpinner(divisor, minimum, maximum, initial)
slider.valueChanged.connect(lambda x: self.spinner.setValue(x))
self.spinner.valueChanged.connect(lambda x: slider.setValue(x))
self.addWidget(slider)
self.addWidget(self.spinner)
def __init__(self, label: str, minimum: int, maximum: int, initial: int) -> None:
super().__init__()
self.addWidget(QLabel(label), 0, 0)
slider = QSlider(Qt.Horizontal)
slider.setMinimum(minimum)
slider.setMaximum(maximum)
slider.setValue(initial)
self.spinner = TenthsSpinner(minimum, maximum, initial)
slider.valueChanged.connect(lambda x: self.spinner.setValue(x))
self.spinner.valueChanged.connect(lambda x: slider.setValue(x))
self.addWidget(slider, 1, 0)
self.addWidget(self.spinner, 1, 1)
def createSlider(self):
hbox = QHBoxLayout()
self.slider = QSlider()
self.slider.setOrientation(Qt.Horizontal)
self.slider.setTickPosition(QSlider.TicksBelow)
self.slider.setTickInterval(10)
self.slider.setMinimum(0)
self.slider.setMaximum(100)
self.slider.valueChanged.connect(self.changeValue)
self.label = QLabel("0")
self.setFont(QtGui.QFont("Sanserif", 15))
hbox.addWidget(self.slider)
hbox.addWidget(self.label)
self.setLayout(hbox)
class Window(QWidget) :
def __init__(self):
QWidget.__init__(self)
self.setFixedSize(500,300)
self.__layout=QHBoxLayout()
self.__progress_bar=QProgressBar()
self.__slider=QSlider()
self.__layout.addWidget(self.__progress_bar)
self.__layout.addWidget(self.__slider)
self.__slider.valueChanged.connect(self.Signal)
self.setLayout(self.__layout)
def Signal(self):
self.Slot(self.__slider.value())
self.hide()
self.show()
def Slot(self,value):
self.__progress_bar.setValue(self.__slider.value())
class BSlider(QWidget):
def __init__(self, onValueChanged, minRange=0, maxRange=10, value=5):
super(BSlider, self).__init__()
# initializing values
self.onValueChanged = onValueChanged
self.minRange = minRange
self.maxRange = maxRange
self.value = value
font_for_value_label = QFont("SansSerif", 13)
self.minLabel = QLabel(str(minRange), self)
self.maxLabel = QLabel(str(maxRange), self)
self.valueLabel = QLabel(str(value), self)
self.valueLabel.setFont(font_for_value_label)
self.minLabel.setFont(font_for_value_label)
self.maxLabel.setFont(font_for_value_label)
self.slider = QSlider(Qt.Horizontal, self)
self.slider.setRange(self.minRange, self.maxRange)
self.slider.setValue(self.value)
# setting up signals and slots aka events
self.slider.valueChanged[int].connect(self.onSliderValueChanged)
self.hbox = QHBoxLayout()
self.hbox.addWidget(self.minLabel)
self.hbox.addWidget(self.slider)
self.hbox.addWidget(self.maxLabel)
self.vbox = QVBoxLayout()
self.vbox.addLayout(self.hbox)
self.vbox.addWidget(self.valueLabel)
self.valueLabel.setAlignment(QtCore.Qt.AlignCenter)
self.setLayout(self.vbox)
self.setFixedHeight(80)
def onSliderValueChanged(self, value):
if JointSplitterInterface.connected:
self.value = value
self.valueLabel.setText(str(value))
self.onValueChanged()
def initUI(self):
slider = QSlider(Qt.Horizontal, self) #Horizontal水平滑块控件,Vertical垂直滑块控件
slider.setMinimum(10)
slider.setMaximum(500)
slider.setGeometry(30, 40, 100, 30)
slider.valueChanged[int].connect(self.changeValue)
self.label = QLabel(self)
self.label.setGeometry(160, 40, 80, 30)
self.setGeometry(300, 300, 280, 170)
self.setWindowTitle('QSlider控件')
self.show()
def __init__(self, parent = None):
super(sliderdemo, self).__init__(parent)
layout = QVBoxLayout()
self.l1 = QLabel("Hello")
self.l1.setAlignment(Qt.AlignCenter)
layout.addWidget(self.l1)
self.sl = QSlider(Qt.Horizontal)
self.sl.setMinimum(10)
self.sl.setMaximum(30)
self.sl.setValue(20)
self.sl.setTickPosition(QSlider.TicksBelow)
self.sl.setTickInterval(5)
layout.addWidget(self.sl)
self.sl.valueChanged.connect(self.valuechange)
self.setLayout(layout)
self.setWindowTitle("SpinBox demo")
def make_slider_layout(self, value_changed_func, val=0):
slider = QSlider(QtCore.Qt.Horizontal, self)
slider.setMinimum(self.slider_range[0])
slider.setMaximum(self.slider_range[1])
slider.setValue(val * 100)
slider.valueChanged[int].connect(value_changed_func)
layout_slider = QVBoxLayout()
layout_slider.addWidget(slider)
txt = QLabel()
layout_slider.addWidget(txt)
txt.setAlignment(QtCore.Qt.AlignHCenter)
return layout_slider, slider, txt
def __init__(self):
QWidget.__init__(self)
self.amtLabel = QLabel('Loan Amount')
self.roiLabel = QLabel('Rate of Interest')
self.yrsLabel = QLabel('No. of Years')
self.emiLabel = QLabel('EMI per month')
self.emiValue = QLCDNumber()
self.emiValue.setSegmentStyle(QLCDNumber.Flat)
self.emiValue.setFixedSize(QSize(130, 30))
self.emiValue.setDigitCount(8)
self.amtText = QLineEdit('10000')
self.roiSpin = QSpinBox()
self.roiSpin.setMinimum(1)
self.roiSpin.setMaximum(15)
self.yrsSpin = QSpinBox()
self.yrsSpin.setMinimum(1)
self.yrsSpin.setMaximum(20)
self.roiDial = QDial()
self.roiDial.setNotchesVisible(True)
self.roiDial.setMaximum(15)
self.roiDial.setMinimum(1)
self.roiDial.setValue(1)
self.yrsSlide = QSlider(Qt.Horizontal)
self.yrsSlide.setMaximum(20)
self.yrsSlide.setMinimum(1)
self.calculateButton = QPushButton('Calculate EMI')
self.myGridLayout = QGridLayout()
self.myGridLayout.addWidget(self.amtLabel, 0, 0)
self.myGridLayout.addWidget(self.roiLabel, 1, 0)
self.myGridLayout.addWidget(self.yrsLabel, 2, 0)
self.myGridLayout.addWidget(self.amtText, 0, 1)
self.myGridLayout.addWidget(self.roiSpin, 1, 1)
self.myGridLayout.addWidget(self.yrsSpin, 2, 1)
self.myGridLayout.addWidget(self.roiDial, 1, 2)
self.myGridLayout.addWidget(self.yrsSlide, 2, 2)
self.myGridLayout.addWidget(self.calculateButton, 3, 1)
self.setLayout(self.myGridLayout)
self.setWindowTitle("A simple EMI calculator")
self.roiDial.valueChanged.connect(self.roiSpin.setValue)
self.connect(self.roiSpin, SIGNAL("valueChanged(int)"), self.roiDial.setValue)
self.yrsSlide.valueChanged.connect(self.yrsSpin.setValue)
self.connect(self.yrsSpin, SIGNAL("valueChanged(int)"),self.yrsSlide, SLOT("setValue(int)"))
self.connect(self.calculateButton, SIGNAL("clicked()"),self.showEMI)
def initUI(self):
lcd = QLCDNumber(self)
sld = QSlider(QtCore.Qt.Horizontal, self)
vbox = QVBoxLayout()
vbox.addWidget(lcd)
vbox.addWidget(sld)
self.setLayout(vbox)
sld.valueChanged.connect(lcd.display)
def __init__(self, parent=None):
super(MaFenetrePrincipale, self).__init__(parent)
self.compteur = MonPainter()
self.slider = QSlider(QtCore.Qt.Horizontal)
self.layout = QtWidgets.QVBoxLayout()
self.layout.addWidget(self.compteur)
self.layout.addWidget(self.slider)
self.setLayout(self.layout)
self.slider.valueChanged.connect(self.compteur.setValeur)
def __init__(self, parent=None):
super().__init__(parent)
hlayout = QHBoxLayout()
hlayout.setContentsMargins(0, 0, 0, 0)
hlayout.setSpacing(2)
self.edit = QSpinBox()
self.edit.setMinimumWidth(40)
self.edit.setButtonSymbols(QAbstractSpinBox.NoButtons)
self.slider = QSlider(Qt.Horizontal)
hlayout.addWidget(self.edit)
hlayout.addWidget(self.slider)
self.setLayout(hlayout)
self.slider.valueChanged.connect(self.setValue)
self.edit.valueChanged.connect(self.setValue)
def __init__(self, parent, header, edit=False):
super().__init__(parent)
self.header = header
# LAYOUTS
self.grid = QGridLayout()
self.v_layout = QVBoxLayout()
self.h_layout = QHBoxLayout()
# FIELDS
self.header_label = QLabel(f'{self.header["name"]} : ', self)
self.header_label.setFixedWidth(100)
self.input = QLineEdit(self)
self.exact = QCheckBox("Exact", self)
self.exact.setToolTip(f"Value in '{self.header['name']}' must be exacly '{self.input.text()}'")
self.exact.stateChanged.connect(self.exact_checked)
self.slider = None
if self.header["data_type"]["type"] == "int":
self.slider = QSlider(Qt.Horizontal, self)
(self.slider.min_v, self.slider.max_v) = self.parent().get_min_max(self.header["name"])
self.slider.setMinimum(self.slider.min_v)
self.slider.setMaximum(self.slider.max_v)
self.slider.valueChanged.connect(self.slider_value_changed)
self.slider.hint = QLabel(f'{self.slider.minimum()} - {self.slider.value()}', self)
# SET UP
self.h_layout.addWidget(self.input)
self.h_layout.addWidget(self.exact)
self.v_layout.addLayout(self.h_layout)
if self.slider is not None:
self.v_layout.addWidget(self.slider.hint)
self.v_layout.addWidget(self.slider)
self.grid.addWidget(self.header_label, 0, 0)
self.grid.addLayout(self.v_layout, 0, 1)
self.setLayout(self.grid)
class LabelledSliderWidget:
def __init__(self, min: int, max: int, label: str):
self.layout = QHBoxLayout()
self.slider = QSlider(Qt.Horizontal)
self.layout.addWidget(self.slider)
self.label = QLabel(text=label)
self.layout.addWidget(self.label)
self.slider.setMinimum(int(min))
self.slider.setMaximum(int(max))
self.slider.valueChanged.connect(self._on_slider_valuechange)
def _on_slider_valuechange(self, value: int):
self.label.setText(str(value))
@property
def connect(self):
return self.slider.valueChanged.connect
def initializeWindow(self):
layout = QVBoxLayout()
self.m_deviceBox = QComboBox()
self.m_deviceBox.activated[int].connect(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()
self.m_modeButton.clicked.connect(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)
self.m_volumeSlider.valueChanged.connect(self.volumeChanged)
volumeBox.addWidget(volumeLabel)
volumeBox.addWidget(self.m_volumeSlider)
layout.addLayout(volumeBox)
window = QWidget()
window.setLayout(layout)
self.setCentralWidget(window)
def createSlider(self, changedSignal, setterSlot):
slider = QSlider(Qt.Vertical)
slider.setRange(0, 360 * 16)
slider.setSingleStep(16)
slider.setPageStep(15 * 16)
slider.setTickInterval(15 * 16)
slider.setTickPosition(QSlider.TicksRight)
self.glWidget.connect(slider, SIGNAL("valueChanged(int)"), setterSlot)
self.connect(self.glWidget, changedSignal, slider, SLOT("setValue(int)"))
return slider
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.playlist = QMediaPlaylist()
self.player = QMediaPlayer()
toolBar = QToolBar()
self.addToolBar(toolBar)
fileMenu = self.menuBar().addMenu("&File")
openAction = QAction(QIcon.fromTheme("document-open"),
"&Open...", self, shortcut=QKeySequence.Open,
triggered=self.open)
fileMenu.addAction(openAction)
exitAction = QAction(QIcon.fromTheme("application-exit"), "E&xit",
self, shortcut="Ctrl+Q", triggered=self.close)
fileMenu.addAction(exitAction)
playMenu = self.menuBar().addMenu("&Play")
playIcon = self.style().standardIcon(QStyle.SP_MediaPlay)
self.playAction = toolBar.addAction(playIcon, "Play")
self.playAction.triggered.connect(self.player.play)
playMenu.addAction(self.playAction)
previousIcon = self.style().standardIcon(QStyle.SP_MediaSkipBackward)
self.previousAction = toolBar.addAction(previousIcon, "Previous")
self.previousAction.triggered.connect(self.previousClicked)
playMenu.addAction(self.previousAction)
pauseIcon = self.style().standardIcon(QStyle.SP_MediaPause)
self.pauseAction = toolBar.addAction(pauseIcon, "Pause")
self.pauseAction.triggered.connect(self.player.pause)
playMenu.addAction(self.pauseAction)
nextIcon = self.style().standardIcon(QStyle.SP_MediaSkipForward)
self.nextAction = toolBar.addAction(nextIcon, "Next")
self.nextAction.triggered.connect(self.playlist.next)
playMenu.addAction(self.nextAction)
stopIcon = self.style().standardIcon(QStyle.SP_MediaStop)
self.stopAction = toolBar.addAction(stopIcon, "Stop")
self.stopAction.triggered.connect(self.player.stop)
playMenu.addAction(self.stopAction)
self.volumeSlider = QSlider()
self.volumeSlider.setOrientation(Qt.Horizontal)
self.volumeSlider.setMinimum(0)
self.volumeSlider.setMaximum(100)
self.volumeSlider.setFixedWidth(app.desktop().availableGeometry(self).width() / 10)
self.volumeSlider.setValue(self.player.volume())
self.volumeSlider.setTickInterval(10)
self.volumeSlider.setTickPosition(QSlider.TicksBelow)
self.volumeSlider.setToolTip("Volume")
self.volumeSlider.valueChanged.connect(self.player.setVolume)
toolBar.addWidget(self.volumeSlider)
aboutMenu = self.menuBar().addMenu("&About")
aboutQtAct = QAction("About &Qt", self, triggered=qApp.aboutQt)
aboutMenu.addAction(aboutQtAct)
self.videoWidget = QVideoWidget()
self.setCentralWidget(self.videoWidget)
self.player.setPlaylist(self.playlist)
self.player.stateChanged.connect(self.updateButtons)
self.player.setVideoOutput(self.videoWidget)
self.updateButtons(self.player.state())
def open(self):
fileDialog = QFileDialog(self)
supportedMimeTypes = QMediaPlayer.supportedMimeTypes()
if not supportedMimeTypes:
supportedMimeTypes.append("video/x-msvideo") # AVI
fileDialog.setMimeTypeFilters(supportedMimeTypes)
moviesLocation = QStandardPaths.writableLocation(QStandardPaths.MoviesLocation)
fileDialog.setDirectory(moviesLocation)
if fileDialog.exec_() == QDialog.Accepted:
self.playlist.addMedia(fileDialog.selectedUrls()[0])
self.player.play()
def previousClicked(self):
# Go to 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:
player.setPosition(0)
def updateButtons(self, state):
mediaCount = self.playlist.mediaCount()
self.playAction.setEnabled(mediaCount > 0
and state != QMediaPlayer.PlayingState)
self.pauseAction.setEnabled(state == QMediaPlayer.PlayingState)
self.stopAction.setEnabled(state != QMediaPlayer.StoppedState)
self.previousAction.setEnabled(self.player.position() > 0)
self.nextAction.setEnabled(mediaCount > 1)
def __init__(self):
super(MainWindow, self).__init__()
self.playlist = QMediaPlaylist()
self.player = QMediaPlayer()
toolBar = QToolBar()
self.addToolBar(toolBar)
fileMenu = self.menuBar().addMenu("&File")
openAction = QAction(QIcon.fromTheme("document-open"),
"&Open...", self, shortcut=QKeySequence.Open,
triggered=self.open)
fileMenu.addAction(openAction)
exitAction = QAction(QIcon.fromTheme("application-exit"), "E&xit",
self, shortcut="Ctrl+Q", triggered=self.close)
fileMenu.addAction(exitAction)
playMenu = self.menuBar().addMenu("&Play")
playIcon = self.style().standardIcon(QStyle.SP_MediaPlay)
self.playAction = toolBar.addAction(playIcon, "Play")
self.playAction.triggered.connect(self.player.play)
playMenu.addAction(self.playAction)
previousIcon = self.style().standardIcon(QStyle.SP_MediaSkipBackward)
self.previousAction = toolBar.addAction(previousIcon, "Previous")
self.previousAction.triggered.connect(self.previousClicked)
playMenu.addAction(self.previousAction)
pauseIcon = self.style().standardIcon(QStyle.SP_MediaPause)
self.pauseAction = toolBar.addAction(pauseIcon, "Pause")
self.pauseAction.triggered.connect(self.player.pause)
playMenu.addAction(self.pauseAction)
nextIcon = self.style().standardIcon(QStyle.SP_MediaSkipForward)
self.nextAction = toolBar.addAction(nextIcon, "Next")
self.nextAction.triggered.connect(self.playlist.next)
playMenu.addAction(self.nextAction)
stopIcon = self.style().standardIcon(QStyle.SP_MediaStop)
self.stopAction = toolBar.addAction(stopIcon, "Stop")
self.stopAction.triggered.connect(self.player.stop)
playMenu.addAction(self.stopAction)
self.volumeSlider = QSlider()
self.volumeSlider.setOrientation(Qt.Horizontal)
self.volumeSlider.setMinimum(0)
self.volumeSlider.setMaximum(100)
self.volumeSlider.setFixedWidth(app.desktop().availableGeometry(self).width() / 10)
self.volumeSlider.setValue(self.player.volume())
self.volumeSlider.setTickInterval(10)
self.volumeSlider.setTickPosition(QSlider.TicksBelow)
self.volumeSlider.setToolTip("Volume")
self.volumeSlider.valueChanged.connect(self.player.setVolume)
toolBar.addWidget(self.volumeSlider)
aboutMenu = self.menuBar().addMenu("&About")
aboutQtAct = QAction("About &Qt", self, triggered=qApp.aboutQt)
aboutMenu.addAction(aboutQtAct)
self.videoWidget = QVideoWidget()
self.setCentralWidget(self.videoWidget)
self.player.setPlaylist(self.playlist)
self.player.stateChanged.connect(self.updateButtons)
self.player.setVideoOutput(self.videoWidget)
self.updateButtons(self.player.state())
class AudioTest(QMainWindow):
PUSH_MODE_LABEL = "Enable push mode"
PULL_MODE_LABEL = "Enable pull mode"
SUSPEND_LABEL = "Suspend playback"
RESUME_LABEL = "Resume playback"
DurationSeconds = 1
ToneSampleRateHz = 600
DataSampleRateHz = 44100
def __init__(self):
super(AudioTest, self).__init__()
self.m_device = QAudioDeviceInfo.defaultOutputDevice()
self.m_output = None
self.initializeWindow()
self.initializeAudio()
def initializeWindow(self):
layout = QVBoxLayout()
self.m_deviceBox = QComboBox()
self.m_deviceBox.activated[int].connect(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()
self.m_modeButton.clicked.connect(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)
self.m_volumeSlider.valueChanged.connect(self.volumeChanged)
volumeBox.addWidget(volumeLabel)
volumeBox.addWidget(self.m_volumeSlider)
layout.addLayout(volumeBox)
window = QWidget()
window.setLayout(layout)
self.setCentralWidget(window)
def initializeAudio(self):
self.m_pullTimer = QTimer(self)
self.m_pullTimer.timeout.connect(self.pullTimerExpired)
self.m_pullMode = True
self.m_format = QAudioFormat()
self.m_format.setSampleRate(self.DataSampleRateHz)
self.m_format.setChannelCount(1)
self.m_format.setSampleSize(16)
self.m_format.setCodec('audio/pcm')
self.m_format.setByteOrder(QAudioFormat.LittleEndian)
self.m_format.setSampleType(QAudioFormat.SignedInt)
info = QAudioDeviceInfo(QAudioDeviceInfo.defaultOutputDevice())
if not info.isFormatSupported(self.m_format):
qWarning("Default format not supported - trying to use nearest")
self.m_format = info.nearestFormat(self.m_format)
self.m_generator = Generator(self.m_format,
self.DurationSeconds * 1000000, self.ToneSampleRateHz, self)
self.createAudioOutput()
def createAudioOutput(self):
self.m_audioOutput = QAudioOutput(self.m_device, self.m_format)
self.m_audioOutput.notify.connect(self.notified)
self.m_audioOutput.stateChanged.connect(self.handleStateChanged)
self.m_generator.start()
self.m_audioOutput.start(self.m_generator)
self.m_volumeSlider.setValue(self.m_audioOutput.volume() * 100)
def deviceChanged(self, index):
self.m_pullTimer.stop()
self.m_generator.stop()
self.m_audioOutput.stop()
self.m_device = self.m_deviceBox.itemData(index)
self.createAudioOutput()
def volumeChanged(self, value):
if self.m_audioOutput is not None:
self.m_audioOutput.setVolume(value / 100.0)
def notified(self):
qWarning("bytesFree = %d, elapsedUSecs = %d, processedUSecs = %d" % (
self.m_audioOutput.bytesFree(),
self.m_audioOutput.elapsedUSecs(),
self.m_audioOutput.processedUSecs()))
def pullTimerExpired(self):
if self.m_audioOutput is not None and self.m_audioOutput.state() != QAudio.StoppedState:
chunks = self.m_audioOutput.bytesFree() // self.m_audioOutput.periodSize()
for _ in range(chunks):
data = self.m_generator.read(self.m_audioOutput.periodSize())
if data is None or len(data) != self.m_audioOutput.periodSize():
break
self.m_output.write(data)
def toggleMode(self):
self.m_pullTimer.stop()
self.m_audioOutput.stop()
if self.m_pullMode:
self.m_modeButton.setText(self.PULL_MODE_LABEL)
self.m_output = self.m_audioOutput.start()
self.m_pullMode = False
self.m_pullTimer.start(20)
else:
self.m_modeButton.setText(self.PUSH_MODE_LABEL)
self.m_pullMode = True
self.m_audioOutput.start(self.m_generator)
self.m_suspendResumeButton.setText(self.SUSPEND_LABEL)
def toggleSuspendResume(self):
if self.m_audioOutput.state() == QAudio.SuspendedState:
qWarning("status: Suspended, resume()")
self.m_audioOutput.resume()
self.m_suspendResumeButton.setText(self.SUSPEND_LABEL)
elif self.m_audioOutput.state() == QAudio.ActiveState:
qWarning("status: Active, suspend()")
self.m_audioOutput.suspend()
self.m_suspendResumeButton.setText(self.RESUME_LABEL)
elif self.m_audioOutput.state() == QAudio.StoppedState:
qWarning("status: Stopped, resume()")
self.m_audioOutput.resume()
self.m_suspendResumeButton.setText(self.SUSPEND_LABEL)
elif self.m_audioOutput.state() == QAudio.IdleState:
qWarning("status: IdleState")
stateMap = {
QAudio.ActiveState: "ActiveState",
QAudio.SuspendedState: "SuspendedState",
QAudio.StoppedState: "StoppedState",
QAudio.IdleState: "IdleState"}
def handleStateChanged(self, state):
qWarning("state = " + self.stateMap.get(state, "Unknown"))
