def change_deltagen_port(self):
box = QMessageBox(self)
box.setText(
_('Port zwischen 3000-3999 angeben. '
'Muss mit DeltaGen>Preferences>Tools>External Commands übereinstimmen.'
))
box.setWindowTitle(_('DeltaGen Kommando Port'))
port = QSpinBox(box)
port.setMinimum(3000)
port.setMaximum(3999)
port.setValue(KnechtSettings.dg.get('port', DG_TCP_PORT))
box.layout().addWidget(port,
box.layout().rowCount() - 1, 0, 1,
box.layout().columnCount())
box.layout().addWidget(
box.layout().takeAt(box.layout().rowCount() - 1).widget(),
box.layout().rowCount(), 0, 1,
box.layout().columnCount())
box.exec_()
if 3000 <= port.value() <= 3999:
KnechtSettings.dg['port'] = port.value()
box = QMessageBox(self)
box.setText(
_('Anwendung neu starten um geänderten Port zu übernehmen.'))
box.setWindowTitle(_('Neustart erforderlich'))
box.exec_()
def createEditor(self, parent, option, index):
spinBox = QSpinBox(parent)
spinBox.setMinimum(-100000)
spinBox.setMaximum(100000)
self.connect(spinBox, SIGNAL("valueChanged(int)"), self,
SLOT("valueChanged()"))
return spinBox
class Config(SignalNode.Config):
"""Config widget displayed for ArtificialDelay."""
def __init__(self, parent=None):
super().__init__(parent=parent)
self.delay = QSpinBox()
self.delay.setSuffix(" ms")
self.delay.setMinimum(0)
self.delay.setMaximum(1000000)
self.delay.valueChanged.connect(self.updateModel)
layout = QFormLayout()
self.setLayout(layout)
layout.addRow("Delay:", self.delay)
def updateModel(self):
n = self.node()
if n is None:
return
n.setDelay(self.delay.value())
def updateView(self):
n = self.node()
if n is None:
return
self.delay.blockSignals(True)
self.delay.setValue(n.delay())
self.delay.blockSignals(False)
def __create_spinbox_label(self,
value: int,
label: str,
minimum: int,
maximum: int,
min_width: int = 200) -> Tuple[Dict, Dict]:
"""__create_line_label will create a spinner and corresponding label
Arguments:
value {int} -- Default value
label {str} -- Label name
minimum {int} -- Minimum value
maximum {int} -- Maximum value
min_width {int} -- Minium width (default: {200})
Returns:
Tuple[Dict, Dict] -- Line Edit, Label
"""
spin_box = QSpinBox()
spin_box.setValue(value)
spin_box.setMinimumWidth(min_width)
spin_box.setMinimum(minimum)
spin_box.setMaximum(maximum)
label = QLabel(label)
label.setBuddy(spin_box)
return spin_box, label
class SpinBoxAction(QWidget):
def __init__(self,
parent=None,
text: str = "",
min: int = 0,
max: int = 10,
val: int = 5):
super().__init__(parent=parent)
self.setLayout(QtWidgets.QHBoxLayout(self))
self.label = QLabel(text)
self.layout().addWidget(self.label)
self.layout().setMargin(1)
self.combo = QSpinBox(self)
self.layout().addWidget(self.combo)
self.setRange(min, max)
self.combo.setValue(val)
def setText(self, text: str) -> None:
self.label.setText(text)
def setRange(self, min: int, max: int) -> None:
self.combo.setMinimum(min)
self.combo.setMaximum(max)
def getSelectedItem(self) -> int:
return self.combo.value()
class MainWindow(QDialog):
def onSpinPointsChanged(self):
self.OpenGLWidget.setIterations(self.iterationsSpinBox.value())
self.iterationsSlider.setValue(self.iterationsSpinBox.value())
# onSpinPointsChanged
def onSliderPointsChanged(self):
self.OpenGLWidget.setIterations(self.iterationsSpinBox.value())
self.iterationsSpinBox.setValue(self.iterationsSlider.value())
# onSliderPointsChanged
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)
class QFlightSlotEditor(QGroupBox):
def __init__(self, package_model: PackageModel, flight: Flight,
game: Game):
super().__init__("Slots")
self.package_model = package_model
self.flight = flight
self.game = game
self.inventory = self.game.aircraft_inventory.for_control_point(
flight.from_cp)
available = self.inventory.available(self.flight.unit_type)
max_count = self.flight.count + available
if max_count > 4:
max_count = 4
layout = QGridLayout()
self.aircraft_count = QLabel("Aircraft count:")
self.aircraft_count_spinner = QSpinBox()
self.aircraft_count_spinner.setMinimum(1)
self.aircraft_count_spinner.setMaximum(max_count)
self.aircraft_count_spinner.setValue(flight.count)
self.aircraft_count_spinner.valueChanged.connect(
self._changed_aircraft_count)
layout.addWidget(self.aircraft_count, 0, 0)
layout.addWidget(self.aircraft_count_spinner, 0, 1)
layout.addWidget(QLabel("Squadron:"), 1, 0)
layout.addWidget(QLabel(str(self.flight.squadron)), 1, 1)
layout.addWidget(QLabel("Assigned pilots:"), 2, 0)
self.roster_editor = FlightRosterEditor(flight.roster)
layout.addLayout(self.roster_editor, 2, 1)
self.setLayout(layout)
def _changed_aircraft_count(self):
old_count = self.flight.count
new_count = int(self.aircraft_count_spinner.value())
self.game.aircraft_inventory.return_from_flight(self.flight)
self.flight.resize(new_count)
try:
self.game.aircraft_inventory.claim_for_flight(self.flight)
except ValueError:
# The UI should have prevented this, but if we ran out of aircraft
# then roll back the inventory change.
difference = new_count - self.flight.count
available = self.inventory.available(self.flight.unit_type)
logging.error(
f"Could not add {difference} additional aircraft to "
f"{self.flight} because {self.flight.departure} has only "
f"{available} {self.flight.unit_type} remaining")
self.game.aircraft_inventory.claim_for_flight(self.flight)
self.flight.resize(old_count)
return
self.roster_editor.resize(new_count)
def __init__(self, comms, parent):
super().__init__(parent)
toolbar = QHBoxLayout()
clearButton = QPushButton("Clear")
clearButton.clicked.connect(self.clear.emit)
level = QComboBox()
level.addItems(LEVELS)
level.currentIndexChanged.connect(self.changeLevel.emit)
maxBlock = QSpinBox()
maxBlock.setMaximum(1000000)
maxBlock.setSingleStep(10)
maxBlock.valueChanged.connect(self.setSize.emit)
maxBlock.setValue(1000)
maxBlock.setMinimumWidth(100)
toolbar.addWidget(clearButton)
toolbar.addWidget(QLabel("Level"))
toolbar.addWidget(level)
toolbar.addWidget(QLabel("Current"))
def addLevelLabel(comm):
currentLevel = QLabel("---")
toolbar.addWidget(currentLevel)
comm.logLevel.connect(lambda data: currentLevel.setText(LEVELS[
_levelToIndex(data.level)]))
if _isCommArray(comms):
for comm in comms:
addLevelLabel(comm)
else:
addLevelLabel(comms)
toolbar.addWidget(QLabel("Max lines"))
toolbar.addWidget(maxBlock)
toolbar.addStretch()
if issubclass(type(parent), QDockWidget):
floatButton = QPushButton(
self.style().standardIcon(QStyle.SP_TitleBarNormalButton), "")
def _toggleFloating():
parent.setFloating(not parent.isFloating())
floatButton.clicked.connect(_toggleFloating)
closeButton = QPushButton(
self.style().standardIcon(QStyle.SP_TitleBarCloseButton), "")
closeButton.clicked.connect(parent.close)
toolbar.addWidget(floatButton)
toolbar.addWidget(closeButton)
self.setLayout(toolbar)
def createEditor(self, parent, option, index):
if index.column() != 4:
return QSqlRelationalDelegate.createEditor(self, parent, option, index)
# For editing the year, return a spinbox with a range from -1000 to 2100.
spinbox = QSpinBox(parent)
spinbox.setFrame(False)
spinbox.setMaximum(2100)
spinbox.setMinimum(-1000)
return spinbox
def createEditor(
self,
parent: QWidget,
option: QStyleOptionViewItem,
index: QModelIndex,
) -> PySide2.QtWidgets.QWidget:
editor = QSpinBox(parent)
editor.setFrame(False)
editor.setMinimum(self.min)
editor.setMaximum(self.max)
return editor
class MyWidget(QWidget):
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 showEMI(self):
loanAmount = float(self.amtText.text())
rateInterest = float(float(self.roiSpin.value() / 12) / 100)
noMonths = int(self.yrsSpin.value() * 12)
emi = (loanAmount * rateInterest) * ((((1 + rateInterest) ** noMonths) / (((1 + rateInterest) ** noMonths) - 1)))
self.emiValue.display(emi)
self.myGridLayout.addWidget(self.emiLabel, 4, 0)
self.myGridLayout.addWidget(self.emiValue, 4, 2)
class MainTab(Tab):
def __init__(self, parent):
self.widget = QWidget()
self.layout = QFormLayout(parent)
self.label_lang = QLabel(_('Languages'))
self.item_lang = AdvComboBox()
self.item_lang.addItems(get_languages())
self.item_lang.setCurrentText(Config().configuration.get(
'current_locale', 'ru_RU'))
self.layout.addRow(self.label_lang, self.item_lang)
self.item_auto_save = QSpinBox()
self.item_auto_save.setMaximum(3600 * 24)
self.item_auto_save.setValue(
Config().configuration.get('autosave_interval'))
self.layout.addRow(_('Auto save') + ' (sec)', self.item_auto_save)
self.item_show_toolbar = QCheckBox(_('Show toolbar'))
self.item_show_toolbar.setChecked(
Config().configuration.get('show_toolbar'))
self.layout.addRow(self.item_show_toolbar)
self.item_open_recent_file = QCheckBox(_('Open recent file'))
self.item_open_recent_file.setChecked(
Config().configuration.get('open_recent_file'))
self.layout.addRow(self.item_open_recent_file)
self.item_use_birthday = QCheckBox(_('Use birthday'))
self.item_use_birthday.setChecked(
Config().configuration.get('use_birthday'))
self.layout.addRow(self.item_use_birthday)
self.item_check_updates = QCheckBox(_('Check updates'))
self.item_check_updates.setChecked(
Config().configuration.get('check_updates'))
# self.layout.addRow(self.item_check_updates)
self.widget.setLayout(self.layout)
def save(self):
Config().configuration.set('current_locale',
self.item_lang.currentText())
Config().configuration.set('autosave_interval',
self.item_auto_save.value())
Config().configuration.set('show_toolbar',
self.item_show_toolbar.isChecked())
Config().configuration.set('open_recent_file',
self.item_open_recent_file.isChecked())
Config().configuration.set('use_birthday',
self.item_use_birthday.isChecked())
Config().configuration.set('check_updates',
self.item_check_updates.isChecked())
class NetPositionUI(QWidget):
def __init__(self, *args, **kwargs):
super(NetPositionUI, self).__init__(*args, **kwargs)
main_layout = QVBoxLayout()
main_layout.setContentsMargins(QMargins(2, 1, 2, 1))
main_layout.setSpacing(1)
# 操作栏
opt_layout = QHBoxLayout()
self.interval_days = QSpinBox(self)
self.interval_days.setMinimum(1)
self.interval_days.setMaximum(30)
self.interval_days.setValue(5)
self.interval_days.setPrefix("日期间隔 ")
self.interval_days.setSuffix(" 天")
opt_layout.addWidget(self.interval_days)
self.query_button = QPushButton('确定', self)
opt_layout.addWidget(self.query_button)
self.tip_label = QLabel('左侧可选择间隔天数,确定查询数据. ', self)
opt_layout.addWidget(self.tip_label)
opt_layout.addStretch()
main_layout.addLayout(opt_layout)
# 显示数据的表
self.data_table = QTableWidget(self)
self.data_table.setFrameShape(QFrame.NoFrame)
self.data_table.setEditTriggers(QAbstractItemView.NoEditTriggers) # 不可编辑
self.data_table.setFocusPolicy(Qt.NoFocus) # 去选中时的虚线框
self.data_table.setAlternatingRowColors(True) # 交替行颜色
self.data_table.horizontalHeader().setDefaultSectionSize(85) # 默认的标题头宽
self.data_table.verticalHeader().hide()
self.data_table.verticalHeader().setDefaultSectionSize(18) # 设置行高(与下行代码同时才生效)
self.data_table.verticalHeader().setMinimumSectionSize(18)
main_layout.addWidget(self.data_table)
self.setLayout(main_layout)
self.tip_label.setObjectName("tipLabel")
self.data_table.setObjectName("dataTable")
self.data_table.horizontalHeader().setStyleSheet("QHeaderView::section,"
"QTableCornerButton::section{height:25px;background-color:rgb(243,245,248);font-weight:bold;font-size:13px}")
self.setStyleSheet(
"#tipLabel{color:rgb(230,50,50);font-weight:bold;}"
"#dataTable::item{padding:2px}"
"#dataTable{selection-color:rgb(255,255,255);selection-background-color:rgb(51,143,255);alternate-background-color:rgb(245,250,248)}"
)
class RelayNumberDialog(QDialog):
def __init__(self):
super().__init__(GlobalAccess().get_main_window())
def exec_(self):
self.init_ui()
return super().exec_()
def init_ui(self):
self.setWindowTitle(_('Relay number'))
self.setWindowIcon(QIcon(config.ICON))
self.setSizeGripEnabled(False)
self.setModal(True)
self.layout = QFormLayout(self)
self.number_label = QLabel(_('First relay number'))
self.number_item = QSpinBox()
self.number_item.setMinimum(1001)
self.number_item.setMaximum(9999)
next_number = get_next_relay_number_protocol()
self.number_item.setValue(next_number)
self.layout.addRow(self.number_label, self.number_item)
def cancel_changes():
self.close()
def apply_changes():
try:
self.apply_changes_impl()
except Exception as e:
logging.error(str(e))
self.close()
button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.button_ok = button_box.button(QDialogButtonBox.Ok)
self.button_ok.setText(_('OK'))
self.button_ok.clicked.connect(apply_changes)
self.button_cancel = button_box.button(QDialogButtonBox.Cancel)
self.button_cancel.setText(_('Cancel'))
self.button_cancel.clicked.connect(cancel_changes)
self.layout.addRow(button_box)
self.show()
def apply_changes_impl(self):
set_next_relay_number(self.number_item.value())
def add_spinner_for(
self, row: int, name: str, description: BoundedIntOption
) -> None:
def on_changed(value: int) -> None:
self.settings.__dict__[name] = value
if description.causes_expensive_game_update:
self.write_full_settings()
spinner = QSpinBox()
spinner.setMinimum(description.min)
spinner.setMaximum(description.max)
spinner.setValue(self.settings.__dict__[name])
spinner.valueChanged.connect(on_changed)
self.addWidget(spinner, row, 1, Qt.AlignRight)
def _on_group_changed(self, combo, v_type='ev', index=0, new_val='N/A'):
self._rearrange_groups()
layout = getattr(self.ui, f"layout_{v_type}{index}")
for i in reversed(range(layout.count())):
item = layout.itemAt(i)
if item.widget() is not None:
item.widget().setParent(None)
for _ in range(5 - combo.currentIndex()):
layout.addWidget(QWidget())
for _ in range(combo.currentIndex()):
spin = QSpinBox(parent=self)
spin.setMaximumSize(QSize(70, 100))
spin.setAlignment(Qt.AlignRight | Qt.AlignTrailing
| Qt.AlignVCenter)
spin.setMinimum(MIN_VARIABLES[v_type][index])
spin.setMaximum(MAX_VARIABLES[v_type][index])
layout.addWidget(spin)
def __init__(self):
super().__init__()
self.setWindowTitle("Line edit")
widget = QSpinBox() # QDoubleSpinBox is for floats
widget.setMinimum(-10)
widget.setMaximum(3)
# or: widget.setRange(-10, 3)
widget.setPrefix("$")
widget.setSuffix("c")
widget.setSingleStep(3)
widget.valueChanged.connect(self.value_changed)
widget.valueChanged[str].connect(self.value_changed_str)
self.setCentralWidget(widget)
def editor(self):
w = QWidget()
l = QFormLayout(w)
width = QSpinBox()
width.setMinimum(1)
width.setMaximum(MAX_WIDTH)
width.setValue(self.desc.width)
l.addRow('Width', width)
def _set_width(value):
self.desc.width = value
width.valueChanged.connect(_set_width)
return w
def createEditor(self, parent):
"""
Creates a QSpinBox instance for GUI editing of integer values
:param parent: the parent of the widget
:return: a QSpinBox instance
"""
res = QSpinBox(parent)
res.setFrame(False)
if "min" in self._options:
res.setMinimum(self._options["min"])
else:
res.setMinimum(-2147483648)
if "max" in self._options:
res.setMaximum(self._options["max"])
else:
res.setMaximum(2147483647)
return res
def __init__(self):
super().__init__()
self.setWindowTitle("My App")
widget = QSpinBox()
# Or: widget = QDoubleSpinBox()
widget.setMinimum(-10)
widget.setMaximum(3)
# Or: widget.setRange(-10,3)
widget.setPrefix("$")
widget.setSuffix("c")
widget.setSingleStep(3) # Or e.g. 0.5 for QDoubleSpinBox
widget.valueChanged.connect(self.value_changed)
widget.textChanged.connect(self.value_changed_str)
self.setCentralWidget(widget)
def show_party_form(self):
party_form = QMessageBox()
party_form.setWindowTitle('Create a network party')
_label_name = QLabel('Name:')
_label_limit = QLabel('Limit of players:')
_edit_name = QLineEdit()
_edit_name.setText(Miscellaneous.get_random_word())
_spinbox_limit = QSpinBox()
_spinbox_limit.setMaximum(10)
_spinbox_limit.setMinimum(1)
_spinbox_limit.setValue(2)
create_party_widgets = [_label_name, _edit_name, _label_limit, _spinbox_limit]
for widget in create_party_widgets:
party_form.layout().addWidget(widget)
party_form.setStandardButtons(QMessageBox.Save | QMessageBox.Cancel)
ret = party_form.exec_()
if ret == QMessageBox.Save:
_party_model = _edit_name.text(), int(_spinbox_limit.text()), self.controller.get_name()
self.controller.create_party(_party_model)
def setupSTFTLayout(self):
STFTSettLayout = QFormLayout(self)
for winType in self.specWindows:
if self.specWindows[winType][1] == int:
paramEdit = QSpinBox()
else:
paramEdit = QDoubleSpinBox()
paramEdit.setMinimum(self.specWindows[winType][2])
paramEdit.setMaximum(self.specWindows[winType][3])
paramEdit.setValue(self.specWindows[winType][4])
paramLabel = QLabel(self.specWindows[winType][0])
self.specWindows[winType] = [paramLabel, paramEdit]
self.winTypeChooser = QComboBox()
for winType in self.winTypes:
self.winTypeChooser.addItem(winType)
self.winTypeChooser.currentTextChanged.connect(self.windowChanged)
self.winTypeChooser.setCurrentText('hann')
STFTSettLayout.addRow('Window type', self.winTypeChooser)
self.maxFreqEdit = QSpinBox()
self.maxFreqEdit.setMaximum(self.fs / 2)
self.maxFreqEdit.setValue(self.defaultParam['maxFreq'])
STFTSettLayout.addRow('Max output Frequency (Hz)', self.maxFreqEdit)
self.nPerSegEdit = QSpinBox()
self.nPerSegEdit.setMaximum(1000)
self.nPerSegEdit.setValue(self.defaultParam['nPerSeg'])
STFTSettLayout.addRow('Length of segment (samples)', self.nPerSegEdit)
self.nOverlapEdit = QSpinBox()
self.nOverlapEdit.setMaximum(1000)
self.nOverlapEdit.setValue(self.defaultParam['nOverlap'])
STFTSettLayout.addRow('Overlap (samples)', self.nOverlapEdit)
for winType in self.specWindows:
paramLabel = self.specWindows[winType][0]
paramEdit = self.specWindows[winType][1]
STFTSettLayout.addRow(paramLabel, paramEdit)
class WindowGroup(AbstractProcessGroup):
def __init__(self, title, fs):
AbstractProcessGroup.__init__(self, title, fs)
self.setupWindowLayout()
def setupWindowLayout(self):
winLayout = QHBoxLayout(self)
wiinSettLayout = QFormLayout()
winLayout.addLayout(wiinSettLayout)
self.winLenEdit = QSpinBox()
self.winLenEdit.setMaximum(10000) #do poprawki
self.winLenEdit.setValue(self.fs / 10)
wiinSettLayout.addRow('Lenght (samples)', self.winLenEdit)
## self.winOverEdit = QSpinBox()
## self.winOverEdit.setMaximum(10000)
## wiinSettLayout.addRow('Overlapping (samples)', self.winOverEdit)
## self.winBackOverEdit = QSpinBox()
## self.winBackOverEdit.setMaximum(10000)
## wiinSettLayout.addRow('Back Overlapping (samples)', self.winBackOverEdit)
def process(self, inData):
self.winLen = self.winLenEdit.value()
## winOver = self.winOverEdit.value()
segNmbr = int(np.shape(inData)[1] / (self.winLen))
progStep = 100.0 / len(inData)
prog = 0
outData = np.copy(inData)
outData = [np.array_split(ch, segNmbr) for ch in outData]
chi = 0
for ch in outData:
for seg in ch:
proc = self.operation(seg)
seg.fill(proc)
prog = prog + progStep
self.progress.emit(int(prog))
chi += 1
outData = [np.concatenate(ch) for ch in outData]
return outData
def editor(self):
w = QWidget()
l = QFormLayout(w)
width = QSpinBox()
width.setMinimum(1)
width.setMaximum(MAX_WIDTH)
width.setValue(self.desc.width)
def _set_width(value):
self.desc.width = value
width.valueChanged.connect(_set_width)
l.addRow('Width', width)
num_inputs = QSpinBox()
num_inputs.setMinimum(2)
num_inputs.setValue(self.desc.num_inputs)
num_inputs.valueChanged.connect(self._set_num_inputs)
l.addRow('Number of inputs', num_inputs)
return w
class Window(QWidget):
def __init__(self):
super(Window, self).__init__()
self.setWindowTitle("Pyside2 SpinBox")
self.setGeometry(300, 300, 300, 300)
self.createSpinBox()
self.spinValue()
def createSpinBox(self):
vbox = QVBoxLayout()
self.label = QLabel()
self.spinBox = QSpinBox()
self.spinBox.setMinimum(10)
self.spinBox.setMaximum(100)
self.spinBox.valueChanged.connect(self.spinValue)
vbox.addWidget(self.label)
vbox.addWidget(self.spinBox)
self.setLayout(vbox)
def spinValue(self):
self.label.setText(str(self.spinBox.value()))
class SequenceRecordItem:
def __init__(self, parent, seq_record, font):
self.seq_record = seq_record
self.parent = parent
self.selectButton = QToolButton(parent)
self.nameLabel = QLabel(parent)
self.nameLabel.setFrameShape(QFrame.Box)
self.nameLabel.setText(str(self.seq_record.name))
self.shiftLeftButton = QToolButton(parent)
self.shiftLeftButton.setArrowType(Qt.LeftArrow)
self.shiftRightButton = QToolButton(parent)
self.shiftRightButton.setArrowType(Qt.RightArrow)
self.shiftSpinBox = QSpinBox(parent)
self.shiftSpinBox.setFrame(True)
self.shiftSpinBox.setButtonSymbols(QSpinBox.NoButtons)
self.shiftSpinBox.setMinimum(-999999)
self.shiftSpinBox.setMaximum(999999)
self.shiftSpinBox.setValue(0)
self.seqLabel = SequenceRecordLabel(parent, font)
self.widgets = [
self.selectButton, self.nameLabel, self.shiftLeftButton,
self.shiftRightButton, self.shiftSpinBox, self.seqLabel
]
self.shiftRightButton.clicked.connect(self.shiftSpinBox.stepUp)
self.shiftLeftButton.clicked.connect(self.shiftSpinBox.stepDown)
selected = False
shift = 0
seq_select_beginning = 0
seq_select_end = 0
class ThresholdGroup(AbstractProcessGroup):
def __init__(self, title, fs):
AbstractProcessGroup.__init__(self, title, fs)
self.setupLayout()
def setupLayout(self):
mainLayout = QFormLayout(self)
self.thresEdit = QSpinBox()
self.thresEdit.setMaximum(999999)
self.thresEdit.setValue(0)
mainLayout.addRow('Threshold value', self.thresEdit)
def process(self, inData):
thresh = self.thresEdit.value()
outData = []
progStep = 100.0 / len(inData)
prog = 0
for chData in inData:
a = [1 if a_ > thresh else 0 for a_ in chData]
outData.append(np.array(a))
prog = prog + progStep
self.progress.emit(int(prog))
return outData
class RelayCloneDialog(QDialog):
def __init__(self):
super().__init__(GlobalAccess().get_main_window())
self.setWindowTitle(_('Clone relay legs'))
self.setWindowIcon(QIcon(config.ICON))
self.setSizeGripEnabled(False)
self.setModal(True)
self.layout = QFormLayout(self)
self.min_bib = QSpinBox()
self.min_bib.setMaximum(10000000)
self.min_bib.setValue(1001)
self.layout.addRow(QLabel(_('Minimal bib')), self.min_bib)
self.max_bib = QSpinBox()
self.max_bib.setMaximum(10000000)
self.max_bib.setValue(2999)
self.layout.addRow(QLabel(_('Maximal bib')), self.max_bib)
self.increment = QSpinBox()
self.increment.setMaximum(10000000)
self.increment.setValue(2000)
self.layout.addRow(QLabel(_('Increment')), self.increment)
def cancel_changes():
self.close()
def apply_changes():
try:
self.apply_changes_impl()
except Exception as e:
logging.error(str(e))
logging.exception(e)
self.close()
button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.button_ok = button_box.button(QDialogButtonBox.Ok)
self.button_ok.setText(_('OK'))
self.button_ok.clicked.connect(apply_changes)
self.button_cancel = button_box.button(QDialogButtonBox.Cancel)
self.button_cancel.setText(_('Cancel'))
self.button_cancel.clicked.connect(cancel_changes)
self.layout.addRow(button_box)
self.show()
def apply_changes_impl(self):
min_bib = self.min_bib.value()
max_bib = self.max_bib.value()
increment = self.increment.value()
clone_relay_legs(min_bib, max_bib, increment)
class QSettingsWindow(QDialog):
def __init__(self, game: Game):
super(QSettingsWindow, self).__init__()
self.game = game
self.setModal(True)
self.setWindowTitle("Settings")
self.setWindowIcon(CONST.ICONS["Settings"])
self.setMinimumSize(600, 250)
self.initUi()
def initUi(self):
self.layout = QGridLayout()
self.categoryList = QListView()
self.right_layout = QStackedLayout()
self.categoryList.setMaximumWidth(175)
self.categoryModel = QStandardItemModel(self.categoryList)
difficulty = QStandardItem("Difficulty")
difficulty.setIcon(CONST.ICONS["Missile"])
difficulty.setEditable(False)
difficulty.setSelectable(True)
generator = QStandardItem("Mission Generator")
generator.setIcon(CONST.ICONS["Generator"])
generator.setEditable(False)
generator.setSelectable(True)
cheat = QStandardItem("Cheat Menu")
cheat.setIcon(CONST.ICONS["Cheat"])
cheat.setEditable(False)
cheat.setSelectable(True)
self.categoryList.setIconSize(QSize(32, 32))
self.categoryModel.appendRow(difficulty)
self.categoryModel.appendRow(generator)
self.categoryModel.appendRow(cheat)
self.categoryList.setSelectionBehavior(QAbstractItemView.SelectRows)
self.categoryList.setModel(self.categoryModel)
self.categoryList.selectionModel().setCurrentIndex(self.categoryList.indexAt(QPoint(1,1)), QItemSelectionModel.Select)
self.categoryList.selectionModel().selectionChanged.connect(self.onSelectionChanged)
self.initDifficultyLayout()
self.initGeneratorLayout()
self.initCheatLayout()
self.right_layout.addWidget(self.difficultyPage)
self.right_layout.addWidget(self.generatorPage)
self.right_layout.addWidget(self.cheatPage)
self.layout.addWidget(self.categoryList, 0, 0, 1, 1)
self.layout.addLayout(self.right_layout, 0, 1, 5, 1)
self.setLayout(self.layout)
def init(self):
pass
def initDifficultyLayout(self):
self.difficultyPage = QWidget()
self.difficultyLayout = QGridLayout()
self.difficultyLayout.setAlignment(Qt.AlignTop)
self.difficultyPage.setLayout(self.difficultyLayout)
self.playerCoalitionSkill = QComboBox()
self.enemyCoalitionSkill = QComboBox()
self.enemyAASkill = QComboBox()
for skill in CONST.SKILL_OPTIONS:
self.playerCoalitionSkill.addItem(skill)
self.enemyCoalitionSkill.addItem(skill)
self.enemyAASkill.addItem(skill)
self.playerCoalitionSkill.setCurrentIndex(CONST.SKILL_OPTIONS.index(self.game.settings.player_skill))
self.enemyCoalitionSkill.setCurrentIndex(CONST.SKILL_OPTIONS.index(self.game.settings.enemy_skill))
self.enemyAASkill.setCurrentIndex(CONST.SKILL_OPTIONS.index(self.game.settings.enemy_vehicle_skill))
self.playerCoalitionSkill.currentIndexChanged.connect(self.applySettings)
self.enemyCoalitionSkill.currentIndexChanged.connect(self.applySettings)
self.enemyAASkill.currentIndexChanged.connect(self.applySettings)
self.difficultyLayout.addWidget(QLabel("Player coalition skill"), 0, 0)
self.difficultyLayout.addWidget(self.playerCoalitionSkill, 0, 1, Qt.AlignRight)
self.difficultyLayout.addWidget(QLabel("Enemy skill"), 1, 0)
self.difficultyLayout.addWidget(self.enemyCoalitionSkill, 1, 1, Qt.AlignRight)
self.difficultyLayout.addWidget(QLabel("Enemy AA and vehicles skill"), 2, 0)
self.difficultyLayout.addWidget(self.enemyAASkill, 2, 1, Qt.AlignRight)
self.difficultyLabel = QComboBox()
[self.difficultyLabel.addItem(t) for t in CONST.LABELS_OPTIONS]
self.difficultyLabel.setCurrentIndex(CONST.LABELS_OPTIONS.index(self.game.settings.labels))
self.difficultyLabel.currentIndexChanged.connect(self.applySettings)
self.difficultyLayout.addWidget(QLabel("In Game Labels"), 3, 0)
self.difficultyLayout.addWidget(self.difficultyLabel, 3, 1, Qt.AlignRight)
self.noNightMission = QCheckBox()
self.noNightMission.setChecked(self.game.settings.night_disabled)
self.noNightMission.toggled.connect(self.applySettings)
self.difficultyLayout.addWidget(QLabel("No night missions"), 4, 0)
self.difficultyLayout.addWidget(self.noNightMission, 4, 1, Qt.AlignRight)
self.mapVisibiitySelection = QComboBox()
self.mapVisibiitySelection.addItem("All", ForcedOptions.Views.All)
if self.game.settings.map_coalition_visibility == ForcedOptions.Views.All:
self.mapVisibiitySelection.setCurrentIndex(0)
self.mapVisibiitySelection.addItem("Fog of War", ForcedOptions.Views.Allies)
if self.game.settings.map_coalition_visibility == ForcedOptions.Views.Allies:
self.mapVisibiitySelection.setCurrentIndex(1)
self.mapVisibiitySelection.addItem("Allies Only", ForcedOptions.Views.OnlyAllies)
if self.game.settings.map_coalition_visibility == ForcedOptions.Views.OnlyAllies:
self.mapVisibiitySelection.setCurrentIndex(2)
self.mapVisibiitySelection.addItem("Own Aircraft Only", ForcedOptions.Views.MyAircraft)
if self.game.settings.map_coalition_visibility == ForcedOptions.Views.MyAircraft:
self.mapVisibiitySelection.setCurrentIndex(3)
self.mapVisibiitySelection.addItem("Map Only", ForcedOptions.Views.OnlyMap)
if self.game.settings.map_coalition_visibility == ForcedOptions.Views.OnlyMap:
self.mapVisibiitySelection.setCurrentIndex(4)
self.mapVisibiitySelection.currentIndexChanged.connect(self.applySettings)
self.difficultyLayout.addWidget(QLabel("Map visibility options"), 5, 0)
self.difficultyLayout.addWidget(self.mapVisibiitySelection, 5, 1, Qt.AlignRight)
self.ext_views = QCheckBox()
self.ext_views.setChecked(self.game.settings.external_views_allowed)
self.ext_views.toggled.connect(self.applySettings)
self.difficultyLayout.addWidget(QLabel("Allow external views"), 6, 0)
self.difficultyLayout.addWidget(self.ext_views, 6, 1, Qt.AlignRight)
def initGeneratorLayout(self):
self.generatorPage = QWidget()
self.generatorLayout = QVBoxLayout()
self.generatorLayout.setAlignment(Qt.AlignTop)
self.generatorPage.setLayout(self.generatorLayout)
self.gameplay = QGroupBox("Gameplay")
self.gameplayLayout = QGridLayout();
self.gameplayLayout.setAlignment(Qt.AlignTop)
self.gameplay.setLayout(self.gameplayLayout)
self.supercarrier = QCheckBox()
self.supercarrier.setChecked(self.game.settings.supercarrier)
self.supercarrier.toggled.connect(self.applySettings)
self.generate_marks = QCheckBox()
self.generate_marks.setChecked(self.game.settings.generate_marks)
self.generate_marks.toggled.connect(self.applySettings)
if not hasattr(self.game.settings, "include_jtac_if_available"):
self.game.settings.include_jtac_if_available = True
self.include_jtac_if_available = QCheckBox()
self.include_jtac_if_available.setChecked(self.game.settings.include_jtac_if_available)
self.include_jtac_if_available.toggled.connect(self.applySettings)
self.gameplayLayout.addWidget(QLabel("Use Supercarrier Module"), 0, 0)
self.gameplayLayout.addWidget(self.supercarrier, 0, 1, Qt.AlignRight)
self.gameplayLayout.addWidget(QLabel("Put Objective Markers on Map"), 1, 0)
self.gameplayLayout.addWidget(self.generate_marks, 1, 1, Qt.AlignRight)
self.gameplayLayout.addWidget(QLabel("Include JTAC (If available)"), 2, 0)
self.gameplayLayout.addWidget(self.include_jtac_if_available, 2, 1, Qt.AlignRight)
self.performance = QGroupBox("Performance")
self.performanceLayout = QGridLayout()
self.performanceLayout.setAlignment(Qt.AlignTop)
self.performance.setLayout(self.performanceLayout)
self.smoke = QCheckBox()
self.smoke.setChecked(self.game.settings.perf_smoke_gen)
self.smoke.toggled.connect(self.applySettings)
self.red_alert = QCheckBox()
self.red_alert.setChecked(self.game.settings.perf_red_alert_state)
self.red_alert.toggled.connect(self.applySettings)
self.arti = QCheckBox()
self.arti.setChecked(self.game.settings.perf_artillery)
self.arti.toggled.connect(self.applySettings)
self.moving_units = QCheckBox()
self.moving_units.setChecked(self.game.settings.perf_moving_units)
self.moving_units.toggled.connect(self.applySettings)
self.infantry = QCheckBox()
self.infantry.setChecked(self.game.settings.perf_infantry)
self.infantry.toggled.connect(self.applySettings)
self.ai_parking_start = QCheckBox()
self.ai_parking_start.setChecked(self.game.settings.perf_ai_parking_start)
self.ai_parking_start.toggled.connect(self.applySettings)
self.destroyed_units = QCheckBox()
self.destroyed_units.setChecked(self.game.settings.perf_destroyed_units)
self.destroyed_units.toggled.connect(self.applySettings)
self.culling = QCheckBox()
self.culling.setChecked(self.game.settings.perf_culling)
self.culling.toggled.connect(self.applySettings)
self.culling_distance = QSpinBox()
self.culling_distance.setMinimum(50)
self.culling_distance.setMaximum(10000)
self.culling_distance.setValue(self.game.settings.perf_culling_distance)
self.culling_distance.valueChanged.connect(self.applySettings)
self.performanceLayout.addWidget(QLabel("Smoke visual effect on frontline"), 0, 0)
self.performanceLayout.addWidget(self.smoke, 0, 1, alignment=Qt.AlignRight)
self.performanceLayout.addWidget(QLabel("SAM starts in RED alert mode"), 1, 0)
self.performanceLayout.addWidget(self.red_alert, 1, 1, alignment=Qt.AlignRight)
self.performanceLayout.addWidget(QLabel("Artillery strikes"), 2, 0)
self.performanceLayout.addWidget(self.arti, 2, 1, alignment=Qt.AlignRight)
self.performanceLayout.addWidget(QLabel("Moving ground units"), 3, 0)
self.performanceLayout.addWidget(self.moving_units, 3, 1, alignment=Qt.AlignRight)
self.performanceLayout.addWidget(QLabel("Generate infantry squads along vehicles"), 4, 0)
self.performanceLayout.addWidget(self.infantry, 4, 1, alignment=Qt.AlignRight)
self.performanceLayout.addWidget(QLabel("AI planes parking start (AI starts in flight if disabled)"), 5, 0)
self.performanceLayout.addWidget(self.ai_parking_start, 5, 1, alignment=Qt.AlignRight)
self.performanceLayout.addWidget(QLabel("Include destroyed units carcass"), 6, 0)
self.performanceLayout.addWidget(self.destroyed_units, 6, 1, alignment=Qt.AlignRight)
self.performanceLayout.addWidget(QHorizontalSeparationLine(), 7, 0, 1, 2)
self.performanceLayout.addWidget(QLabel("Culling of distant units enabled"), 8, 0)
self.performanceLayout.addWidget(self.culling, 8, 1, alignment=Qt.AlignRight)
self.performanceLayout.addWidget(QLabel("Culling distance (km)"), 9, 0)
self.performanceLayout.addWidget(self.culling_distance, 9, 1, alignment=Qt.AlignRight)
self.generatorLayout.addWidget(self.gameplay)
self.generatorLayout.addWidget(QLabel("Disabling settings below may improve performance, but will impact the overall quality of the experience."))
self.generatorLayout.addWidget(self.performance)
def initCheatLayout(self):
self.cheatPage = QWidget()
self.cheatLayout = QGridLayout()
self.cheatPage.setLayout(self.cheatLayout)
self.moneyCheatBox = QGroupBox("Money Cheat")
self.moneyCheatBox.setAlignment(Qt.AlignTop)
self.moneyCheatBoxLayout = QGridLayout()
self.moneyCheatBox.setLayout(self.moneyCheatBoxLayout)
self.cheat25M = QPushButton("Cheat +25M")
self.cheat50M = QPushButton("Cheat +50M")
self.cheat100M = QPushButton("Cheat +100M")
self.cheat200M = QPushButton("Cheat +200M")
self.cheat500M = QPushButton("Cheat +500M")
self.cheat1000M = QPushButton("Cheat +1000M")
self.cheat25M.clicked.connect(lambda: self.cheatMoney(25))
self.cheat50M.clicked.connect(lambda: self.cheatMoney(50))
self.cheat100M.clicked.connect(lambda: self.cheatMoney(100))
self.cheat200M.clicked.connect(lambda: self.cheatMoney(200))
self.cheat500M.clicked.connect(lambda: self.cheatMoney(500))
self.cheat1000M.clicked.connect(lambda: self.cheatMoney(1000))
self.moneyCheatBoxLayout.addWidget(self.cheat25M, 0, 0)
self.moneyCheatBoxLayout.addWidget(self.cheat50M, 0, 1)
self.moneyCheatBoxLayout.addWidget(self.cheat100M, 1, 0)
self.moneyCheatBoxLayout.addWidget(self.cheat200M, 1, 1)
self.moneyCheatBoxLayout.addWidget(self.cheat500M, 2, 0)
self.moneyCheatBoxLayout.addWidget(self.cheat1000M, 2, 1)
self.cheatLayout.addWidget(self.moneyCheatBox, 0, 0)
def cheatMoney(self, amount):
self.game.budget += amount
self.game.informations.append(Information("CHEATER", "You are a cheater and you should feel bad", self.game.turn))
GameUpdateSignal.get_instance().updateGame(self.game)
def applySettings(self):
self.game.settings.player_skill = CONST.SKILL_OPTIONS[self.playerCoalitionSkill.currentIndex()]
self.game.settings.enemy_skill = CONST.SKILL_OPTIONS[self.enemyCoalitionSkill.currentIndex()]
self.game.settings.enemy_vehicle_skill = CONST.SKILL_OPTIONS[self.enemyAASkill.currentIndex()]
self.game.settings.labels = CONST.LABELS_OPTIONS[self.difficultyLabel.currentIndex()]
self.game.settings.night_disabled = self.noNightMission.isChecked()
self.game.settings.map_coalition_visibility = self.mapVisibiitySelection.currentData()
self.game.settings.external_views_allowed = self.ext_views.isChecked()
self.game.settings.generate_marks = self.generate_marks.isChecked()
self.game.settings.include_jtac_if_available = self.include_jtac_if_available.isChecked()
print(self.game.settings.map_coalition_visibility)
self.game.settings.supercarrier = self.supercarrier.isChecked()
self.game.settings.perf_red_alert_state = self.red_alert.isChecked()
self.game.settings.perf_smoke_gen = self.smoke.isChecked()
self.game.settings.perf_artillery = self.arti.isChecked()
self.game.settings.perf_moving_units = self.moving_units.isChecked()
self.game.settings.perf_infantry = self.infantry.isChecked()
self.game.settings.perf_ai_parking_start = self.ai_parking_start.isChecked()
self.game.settings.perf_destroyed_units = self.destroyed_units.isChecked()
self.game.settings.perf_culling = self.culling.isChecked()
self.game.settings.perf_culling_distance = int(self.culling_distance.value())
GameUpdateSignal.get_instance().updateGame(self.game)
def onSelectionChanged(self):
index = self.categoryList.selectionModel().currentIndex().row()
self.right_layout.setCurrentIndex(index)
class Widget(QWidget):
movie_url_label_text = "粘贴有 dailymotion 版的連續劇网址 (例子: https://dramaq.de/cn191023b/): "
def __init__(self):
QWidget.__init__(self)
self.q = None
self.pool = None
self.top = QHBoxLayout()
self.top.setMargin(10)
self.middle = QVBoxLayout()
self.middle.setMargin(10)
self.radioButtonDailyMotionDrama = QRadioButton(
"有 Dailymotion Drama 的網站")
self.radioButtonAny = QRadioButton("其它類型網站 (例如 YouTube)")
self.top.addWidget(self.radioButtonDailyMotionDrama)
self.top.addWidget(self.radioButtonAny)
self.url_label = QLabel()
self.url = QLineEdit()
self.url_label.setBuddy(self.url)
self.middle.addWidget(self.url_label)
self.middle.addWidget(self.url)
self.browse_folder_label = QLabel("下載到：")
self.browseFolder = QPushButton("選擇目錄")
self.browse_folder_label.setBuddy(self.browseFolder)
self.middle.addWidget(self.browse_folder_label)
self.middle.addWidget(self.browseFolder)
self.browse_folder_value = ""
self.bk_cinemae_spin_from = 1
self.bk_cinemae_spin_to = 1
self.fromEpSpinBox = QSpinBox()
self.fromEpSpinBox.setMinimum(1)
self.fromEpSpinBox.setMaximum(2147483647)
self.fromEpLabel = QLabel("&從第幾集開始下載：")
self.fromEpLabel.setBuddy(self.fromEpSpinBox)
self.toEpSpinBox = QSpinBox()
self.toEpSpinBox.setMinimum(1)
self.toEpSpinBox.setMaximum(2147483647)
self.toEpLabel = QLabel("&到第幾集停止下載：")
self.toEpLabel.setBuddy(self.toEpSpinBox)
self.cinema_ly = QHBoxLayout()
#self.cinema_ly.setMargin(10)
self.cinema_ly.addWidget(self.fromEpLabel)
self.cinema_ly.addWidget(self.fromEpSpinBox)
self.cinema_ly.addWidget(self.toEpLabel)
self.cinema_ly.addWidget(self.toEpSpinBox)
self.middle.addLayout(self.cinema_ly)
self.add = QPushButton("開始下載")
self.add.setEnabled(False)
self.middle.addWidget(self.add)
self.stop_me = QPushButton("停止下載")
self.stop_me.setEnabled(False)
self.middle.addWidget(self.stop_me)
self.log_area = QPlainTextEdit()
self.log_area.setReadOnly(True)
self.log_area.setMaximumBlockCount(1000)
self.middle.addWidget(self.log_area)
#self.table_view.setSizePolicy(size)
#self.layout.addWidget(self.table)
self.layout = QVBoxLayout()
self.layout.addLayout(self.top)
self.layout.addLayout(self.middle)
self.setLayout(self.layout)
self.radioButtonDailyMotionDrama.toggled.connect(
self.choose_DailyMotionDrama_widgets)
self.radioButtonAny.toggled.connect(self.choose_Any_widgets)
self.url.textChanged[str].connect(self.check_disable_download)
self.browseFolder.clicked.connect(self.add_folder)
self.add.clicked.connect(self.start_download)
self.stop_me.clicked.connect(self.stop_download)
self.radioButtonDailyMotionDrama.setChecked(
True) #set default only after .connect above
# TESTING PURPOSE
'''
self.url.setText('https://journalflash.com/cn191023b/')
self.browse_folder_value = 'C:/Users/Administrator/Documents/duboku'
'''
#set current process (not queue that one) log handler:
logger = logging.getLogger(__name__)
handler2 = LoggerWriter()
logger.addHandler(handler2)
logger.setLevel(logging.INFO) #DEBUG
handler2.emitter.sigLog.connect(self.log_area.appendPlainText)
sys.stdout = handler2 #LoggerWriter()
#sys.stderr = handler2 #Seems no difference
#handler2.emitter.sigLog.emit('hihi')
@Slot()
def choose_DailyMotionDrama_widgets(self):
if self.radioButtonDailyMotionDrama.isChecked():
self.fromEpLabel.setEnabled(True)
self.toEpLabel.setEnabled(True)
self.fromEpSpinBox.setEnabled(True)
self.toEpSpinBox.setEnabled(True)
self.fromEpSpinBox.setValue(self.bk_cinemae_spin_from)
self.toEpSpinBox.setValue(self.bk_cinemae_spin_to)
self.fromEpLabel.setDisabled(True)
self.toEpLabel.setDisabled(True)
@Slot()
def choose_Any_widgets(self):
if self.radioButtonAny.isChecked():
self.fromEpSpinBox.setDisabled(True)
self.toEpSpinBox.setDisabled(True)
self.bk_cinemae_spin_from = self.fromEpSpinBox.value()
self.bk_cinemae_spin_to = self.toEpSpinBox.value()
self.fromEpSpinBox.setValue(1)
self.toEpSpinBox.setValue(1)
@Slot()
def add_folder(self, s):
#fname = QFileDialog.getOpenFileName(self, 'Open file', "c:\'", "Image files (*.jpg *.gif)")
#fname = QFileDialog.getOpenFileName(self, 'Open file', '', QFileDialog.ShowDirsOnly)
fname = QFileDialog.getExistingDirectory(self, '選擇下載至什麼目錄', '',
QFileDialog.ShowDirsOnly)
#print('repr: ' + repr(fname))
if fname and fname.strip():
fname = fname.strip()
self.browse_folder_value = fname
#if getOpenFileName, will return ('/home/xiaobai/Pictures/disco.jpg', 'Image files (*.jpg *.gif)')
#, while if getExistingDirectory, will return single path string only
self.browseFolder.setText(fname)
self.check_disable_download(fname)
#else:
# print('User cancel')
@Slot()
def check_disable_download(self, s):
if self.url.text() and self.browse_folder_value:
self.add.setEnabled(True)
else:
self.add.setEnabled(False)
def task_done(self, retVal):
self.add.setEnabled(True)
self.stop_me.setEnabled(False)
@Slot()
def stop_download(self):
if self.q:
self.q.close()
if self.pool:
self.pool.terminate()
self.add.setEnabled(True)
self.stop_me.setEnabled(False)
print('下載停止。')
@Slot()
def start_download(self):
if self.fromEpSpinBox.value() > self.toEpSpinBox.value():
self.log_area.setPlainText('[!] 從第幾集必須小於或等於到第幾集。')
return
#No need worry click twice too fast, it seems already handle by PySide2
self.add.setEnabled(False)
self.stop_me.setEnabled(True)
self.log_area.clear()
dest_full_path = self.browse_folder_value
'''
print('dest_full_path: ' + repr(dest_full_path))
print('self.url.text(): ' + repr(self.url.text()))
print('self.fromEpSpinBox.value(): ' + repr(self.fromEpSpinBox.value()))
print('self.toEpSpinBox.value(): ' + repr(self.toEpSpinBox.value()))
'''
import drama_dailymotion_console
#Windows can't set like that bcoz not update for args.url, must put explicitly
#drama_dailymotion_console.redirect_stdout_to_custom_stdout(arg_url, ...etc, LoggerWriter())
#failed other process
handler = LogHandlerOtherProcess()
handler.emitter.sigLog.connect(self.log_area.appendPlainText)
''' #ref current process:
logger = logging.getLogger(__name__)
handler2 = LoggerWriter()
logger.addHandler(handler2)
logger.setLevel(logging.DEBUG)
handler2.emitter.sigLog.connect(self.log_area.appendPlainText)
sys.stdout = handler2 #LoggerWriter()
#handler2.emitter.sigLog.emit('hihi')
'''
#handler = LoggerWriter()
#handler.emitter.sigLog.connect(self.log_area.appendPlainText)
self.q = multiprocessing.Queue()
self.ql = QueueListener(self.q, handler)
self.ql.start()
self.pool = multiprocessing.Pool(1, worker_init, [self.q])
if self.radioButtonDailyMotionDrama.isChecked():
self.pool.apply_async(drama_dailymotion_console.main,
args=(dest_full_path,
self.fromEpSpinBox.value(),
self.toEpSpinBox.value(),
self.url.text(),
LoggerWriterOtherProcess(), False),
callback=self.task_done)
else:
self.pool.apply_async(drama_dailymotion_console.main,
args=(dest_full_path,
self.fromEpSpinBox.value(),
self.toEpSpinBox.value(),
self.url.text(),
LoggerWriterOtherProcess(), True),
callback=self.task_done)
