class ErgebnissVorlage(QWidget):
def __init__(self, parent=None):
super(ErgebnissVorlage, self).__init__(parent)
self.auswahlAlter = QComboBox()
self.auswahlAlter.addItem("Bitte auswählen")
for i in range(3, 18):
self.auswahlAlter.addItem("{} Jahre / Jahrgang {}".format(i, date.today().year - i))
self.auswahlGeschlecht = QComboBox()
self.auswahlGeschlecht.addItem("Bitte auswählen")
self.auswahlGeschlecht.addItem("Männlich")
self.auswahlGeschlecht.addItem("Weiblich")
self.printerProgress = QProgressBar()
self.printerProgress.hide()
self.mainLayout = QFormLayout()
self.mainLayout.addRow(QLabel("Alter:"),self.auswahlAlter)
self.mainLayout.addRow(QLabel("Geschlecht:"),self.auswahlGeschlecht)
self.mainLayout.addRow(self.printerProgress)
self._drucken = QPushButton("Drucken")
self._drucken.clicked.connect(self.drucken)
self.mainLayout.addRow(self._drucken)
self.setLayout(self.mainLayout)
def queryUsers(self,Alter:int, Geschlecht:bool)->list:
return QueryTool().fetchAllByWhere("LG_NGD",WieAlt=Alter,Geschlecht=Geschlecht)
def drucken(self):
self.printerProgress.show()
if (self.auswahlAlter.currentIndex() is 0) and (self.auswahlGeschlecht.currentIndex() is 0):
Alter = range(3,18)
Geschlecht = range(0,2)
else:
Alter = self.auswahlAlter.currentIndex()+2
Alter = range(Alter,Alter+1)
Geschlecht = self.auswahlGeschlecht.currentIndex()-1
Geschlecht = range(Geschlecht,Geschlecht+1)
self.printerProgress.setMaximum(len(Alter)*len(Geschlecht)*10)
self.printerProgress.setValue(0)
prog = 0
for a in Alter:
for g in Geschlecht:
for d in range(10):
ErgebnissVorlagenDrucker(a,g,d)
self.printerProgress.setValue(prog)
prog +=1
self.printerProgress.hide()
class DistanceUSV2(COMCUPluginBase):
def __init__(self, *args):
super().__init__(BrickletDistanceUSV2, *args)
self.dist = self.device
self.cbe_distance = CallbackEmulator(self.dist.get_distance,
None,
self.cb_distance,
self.increase_error_count)
self.current_distance = CurveValueWrapper()
plots = [('Distance', Qt.red, self.current_distance, '{:.1f} cm'.format)]
self.plot_widget = PlotWidget('Distance [cm]', plots, y_resolution=1.0)
self.update_rate_label = QLabel('Update Rate:')
self.update_rate_combo = QComboBox()
self.update_rate_combo.addItem(" 2 Hz")
self.update_rate_combo.addItem("10 Hz")
self.update_rate_combo.currentIndexChanged.connect(self.new_update_rate)
hlayout = QHBoxLayout()
hlayout.addWidget(self.update_rate_label)
hlayout.addWidget(self.update_rate_combo)
hlayout.addStretch()
layout = QVBoxLayout(self)
layout.addWidget(self.plot_widget)
layout.addLayout(hlayout)
def new_update_rate(self):
update_rate = self.update_rate_combo.currentIndex()
self.dist.set_update_rate(update_rate)
def get_update_rate_async(self, update_rate):
self.update_rate_combo.setCurrentIndex(update_rate)
def start(self):
async_call(self.dist.get_update_rate, None, self.get_update_rate_async, self.increase_error_count)
self.cbe_distance.set_period(100)
self.plot_widget.stop = False
def stop(self):
self.cbe_distance.set_period(0)
self.plot_widget.stop = True
def destroy(self):
pass
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickletDistanceUSV2.DEVICE_IDENTIFIER
def cb_distance(self, distance):
self.current_distance.value = distance / 10.0
class Widget(QWidget):
def __init__(self, tool):
super(Widget, self).__init__(tool)
layout = QVBoxLayout()
self.setLayout(layout)
layout.setContentsMargins(0, 0, 0, 0)
self.blockCombo = QComboBox()
self.charmap = CharMapWidget()
layout.addWidget(self.blockCombo)
layout.addWidget(self.charmap)
# size policy of combo
p = self.blockCombo.sizePolicy()
p.setHorizontalPolicy(QSizePolicy.Ignored)
self.blockCombo.setSizePolicy(p)
# size policy of combo popup
p = self.blockCombo.view().sizePolicy()
p.setHorizontalPolicy(QSizePolicy.MinimumExpanding)
self.blockCombo.view().setSizePolicy(p)
model = listmodel.ListModel(_blocks,
display = lambda b: b.name)
self.blockCombo.setModel(model)
# load block setting
name = QSettings().value("charmaptool/last_block", "", str)
if name:
for i, b in enumerate(_blocks):
if b.name == name:
self.blockCombo.setCurrentIndex(i)
break
self.blockCombo.activated[int].connect(self.updateBlock)
self.updateBlock()
self.loadSettings()
app.settingsChanged.connect(self.loadSettings)
def loadSettings(self):
s = QSettings()
s.beginGroup("charmaptool")
font = self.font()
family = s.value("fontfamily", "", str)
if family:
font.setFamily(family)
self.charmap.charmap.setDisplayFont(font)
size = s.value("fontsize", font.pointSizeF(), float)
self.charmap.charmap.setDisplayFontSizeF(size)
def updateBlock(self):
i = self.blockCombo.currentIndex()
if 0 <= i < len(_blocks):
first, last, name = _blocks[i]
self.charmap.charmap.setRange(first, last)
QSettings().setValue("charmaptool/last_block", name)
class FormatChoice( ChoiceWidget ) :
# combobox value
def __init__( self, title, explainer ) :
super().__init__( title, explainer )
#Current color and line style are kept in this QTextCharFormat
self.text_format = QTextCharFormat()
# Set up the underline menu
self.ul_menu = QComboBox()
self.ul_menu.addItems( list( UNDERLINES.values() ) )
self.ul_menu.currentIndexChanged[int].connect(self.ul_change)
self.layout().addWidget( self.ul_menu, 0 )
# Set up the color swatch
self.swatch = Swatch( self )
self.layout().addWidget( self.swatch, 0 )
self.swatch.clicked.connect( self.color_change )
# Set up the text sample
self.sample = Sample()
self.layout().addWidget( self.sample )
self.reset() # set widgets to current value
# Combine the underline choice and swatch color into a QTextCharFormat.
def make_format( self, ul_index, qc ) :
qtcf = QTextCharFormat()
qtcf.setUnderlineStyle( ul_index )
if ul_index == QTextCharFormat.NoUnderline :
qtcf.setBackground(QBrush(qc))
else :
qtcf.setUnderlineColor(qc) # underline color gets a QColor
qtcf.clearBackground()
return qtcf
# Parse self.text_format and display it in the swatch and combobox.
def show_format( self ) :
un = self.text_format.underlineStyle()
if un == QTextCharFormat.NoUnderline :
qc = self.text_format.background().color()
else :
qc = self.text_format.underlineColor()
self.swatch.set_color( qc )
self.ul_menu.setCurrentIndex( un )
self.sample.change_format(self.text_format)
# Handle a change in selection of the underline popup
def ul_change( self, index ) :
self.text_format = self.make_format( index, self.swatch.qc )
self.show_format()
# Handle a click on the color swatch. Show the color dialog. After it
# ends, the Preferences dialog will be behind the main window. Why? Who
# knows! But raise it back up to visibility.
def color_change(self) :
qc = colors.choose_color(
_TR('Browse dialog for color preference',
'Choose a color for scanno marking'),
self.swatch.qc )
BIG_FAT_KLUDGE.raise_()
if qc is not None :
self.text_format = self.make_format( self.ul_menu.currentIndex(), qc )
self.show_format()
class FindInFilesActions(QWidget):
searchRequested = pyqtSignal('QString', bool, bool, bool)
def __init__(self, parent=None):
super().__init__(parent)
self.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Ignored)
self._scope = QComboBox()
self._scope.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.ninjaide = IDE.get_service('ide')
self.ninjaide.filesAndProjectsLoaded.connect(
self._update_combo_projects)
main_layout = QVBoxLayout(self)
hbox = QHBoxLayout()
hbox.addWidget(QLabel(translations.TR_SEARCH_SCOPE))
hbox.addWidget(self._scope)
main_layout.addLayout(hbox)
widgets_layout = QGridLayout()
widgets_layout.setContentsMargins(0, 0, 0, 0)
self._line_search = QLineEdit()
self._line_search.setPlaceholderText(translations.TR_SEARCH_FOR)
main_layout.addWidget(self._line_search)
# TODO: replace
self._check_cs = QCheckBox(translations.TR_SEARCH_CASE_SENSITIVE)
self._check_cs.setChecked(True)
widgets_layout.addWidget(self._check_cs, 2, 0)
self._check_wo = QCheckBox(translations.TR_SEARCH_WHOLE_WORDS)
widgets_layout.addWidget(self._check_wo, 2, 1)
self._check_re = QCheckBox(translations.TR_SEARCH_REGEX)
widgets_layout.addWidget(self._check_re, 3, 0)
self._check_recursive = QCheckBox('Recursive')
widgets_layout.addWidget(self._check_recursive, 3, 1)
main_layout.addLayout(widgets_layout)
main_layout.addStretch(1)
# Connections
self._line_search.returnPressed.connect(self.search_requested)
def _update_combo_projects(self):
projects = self.ninjaide.get_projects()
for nproject in projects.values():
self._scope.addItem(nproject.name, nproject.path)
@property
def current_project_path(self):
"""Returns NProject.path of current project"""
return self._scope.itemData(self._scope.currentIndex())
def search_requested(self):
text = self._line_search.text()
if not text.strip():
return
has_search = self._line_search.text()
cs = self._check_cs.isChecked()
regex = self._check_re.isChecked()
wo = self._check_wo.isChecked()
self.searchRequested.emit(has_search, cs, regex, wo)
class AddPlayerWidget(QWidget):
def __init__(self):
super(AddPlayerWidget, self).__init__()
self.users = {}
# self.setWindowTitle('Add Player')
self.setStyleSheet(style.style_loader.stylesheet)
self.label = QLabel('Enter Name:', self)
self.label_widget = QWidget(self)
label_layout = QBoxLayout(QBoxLayout.LeftToRight)
label_layout.addWidget(self.label)
self.label_widget.setLayout(label_layout)
self.user_box = QComboBox(self)
self.user_box.setFixedWidth(210)
self.user_box.setFixedHeight(50)
self.user_box_widget = QWidget(self)
user_box_layout = QBoxLayout(QBoxLayout.LeftToRight)
user_box_layout.addWidget(self.user_box)
self.user_box_widget.setLayout(user_box_layout)
self.submit_btn = QPushButton('Add Player', self)
self.submit_btn.clicked.connect(self.submit)
self.submit_btn_widget = QWidget(self)
submit_btn_layout = QBoxLayout(QBoxLayout.LeftToRight)
submit_btn_layout.addWidget(self.submit_btn)
self.submit_btn_widget.setLayout(submit_btn_layout)
layout = QFormLayout()
layout.addRow(self.label_widget)
layout.addRow(self.user_box_widget)
layout.addRow(self.submit_btn_widget)
self.setLayout(layout)
self.show()
self.setFixedHeight(self.height())
self.setFixedWidth(self.width())
self.close()
def update(self):
self.user_box.clear()
self.users = um.users()
for user in self.users:
self.user_box.addItem(user.name + ' (' + str(user.id) + ')')
def submit(self):
user = self.users[self.user_box.currentIndex()]
view.notifier.player_added(user.name, user)
self.close()
class PreviewForm(QDialog):
def __init__(self, parent):
super(PreviewForm, self).__init__(parent)
self.encodingComboBox = QComboBox()
encodingLabel = QLabel("&Encoding:")
encodingLabel.setBuddy(self.encodingComboBox)
self.textEdit = QTextEdit()
self.textEdit.setLineWrapMode(QTextEdit.NoWrap)
self.textEdit.setReadOnly(True)
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.encodingComboBox.activated.connect(self.updateTextEdit)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
mainLayout = QGridLayout()
mainLayout.addWidget(encodingLabel, 0, 0)
mainLayout.addWidget(self.encodingComboBox, 0, 1)
mainLayout.addWidget(self.textEdit, 1, 0, 1, 2)
mainLayout.addWidget(buttonBox, 2, 0, 1, 2)
self.setLayout(mainLayout)
self.setWindowTitle("Choose Encoding")
self.resize(400, 300)
def setCodecList(self, codecs):
self.encodingComboBox.clear()
for codec in codecs:
self.encodingComboBox.addItem(codec_name(codec), codec.mibEnum())
def setEncodedData(self, data):
self.encodedData = data
self.updateTextEdit()
def decodedString(self):
return self.decodedStr
def updateTextEdit(self):
mib = self.encodingComboBox.itemData(self.encodingComboBox.currentIndex())
codec = QTextCodec.codecForMib(mib)
data = QTextStream(self.encodedData)
data.setAutoDetectUnicode(False)
data.setCodec(codec)
self.decodedStr = data.readAll()
self.textEdit.setPlainText(self.decodedStr)
class StaffGroup(_base.Container):
@staticmethod
def title(_=_base.translate):
return _("Staff Group")
def accepts(self):
return (StaffGroup, _base.Part)
def createWidgets(self, layout):
self.systemStartLabel = QLabel()
self.systemStart = QComboBox()
self.systemStartLabel.setBuddy(self.systemStart)
self.systemStart.setModel(listmodel.ListModel((
# L10N: Brace like a piano staff
(lambda: _("Brace"), 'system_start_brace'),
# L10N: Bracket like a choir staff
(lambda: _("Bracket"), 'system_start_bracket'),
# L10N: Square bracket like a sub-group
(lambda: _("Square"), 'system_start_square'),
), self.systemStart, display=listmodel.translate_index(0),
icon=lambda item: symbols.icon(item[1])))
self.systemStart.setIconSize(QSize(64, 64))
self.connectBarLines = QCheckBox(checked=True)
box = QHBoxLayout()
box.addWidget(self.systemStartLabel)
box.addWidget(self.systemStart)
layout.addLayout(box)
layout.addWidget(self.connectBarLines)
def translateWidgets(self):
self.systemStartLabel.setText(_("Type:"))
self.connectBarLines.setText(_("Connect Barlines"))
self.connectBarLines.setToolTip(_("If checked, barlines are connected between the staves."))
self.systemStart.model().update()
def build(self, data, builder):
s = self.systemStart.currentIndex()
b = self.connectBarLines.isChecked()
if s == 0:
node = ly.dom.GrandStaff()
if not b:
ly.dom.Line("\\remove Span_bar_engraver", node.getWith())
else:
node = ly.dom.StaffGroup() if b else ly.dom.ChoirStaff()
if s == 2:
node.getWith()['systemStartDelimiter'] = ly.dom.Scheme("'SystemStartSquare")
data.nodes.append(node)
data.music = ly.dom.Simr(node)
class Form(QDialog):
def __init__(self, parent=None):
super().__init__(parent)
principalLabel = QLabel("Principal:")
self.principalSpinBox = QDoubleSpinBox()
self.principalSpinBox.setRange(1, 1000000000)
self.principalSpinBox.setValue(1000)
self.principalSpinBox.setPrefix("$ ")
rateLabel = QLabel("Rate:")
self.rateSpinBox = QDoubleSpinBox()
self.rateSpinBox.setRange(1, 100)
self.rateSpinBox.setValue(5)
self.rateSpinBox.setSuffix(" %")
yearsLabel = QLabel("Years:")
self.yearsComboBox = QComboBox()
self.yearsComboBox.addItem("1 year")
self.yearsComboBox.addItems(["{} years".format(x)
for x in range(2, 26)])
amountLabel = QLabel("Amount")
self.amountLabel = QLabel()
grid = QGridLayout()
grid.addWidget(principalLabel, 0, 0)
grid.addWidget(self.principalSpinBox, 0, 1)
grid.addWidget(rateLabel, 1, 0)
grid.addWidget(self.rateSpinBox, 1, 1)
grid.addWidget(yearsLabel, 2, 0)
grid.addWidget(self.yearsComboBox, 2, 1)
grid.addWidget(amountLabel, 3, 0)
grid.addWidget(self.amountLabel, 3, 1)
self.setLayout(grid)
self.principalSpinBox.valueChanged.connect(self.updateUi)
self.rateSpinBox.valueChanged.connect(self.updateUi)
self.yearsComboBox.currentIndexChanged.connect(self.updateUi)
self.setWindowTitle("Interest")
self.updateUi()
def updateUi(self):
"""Calculates compound interest"""
principal = self.principalSpinBox.value()
rate = self.rateSpinBox.value()
years = self.yearsComboBox.currentIndex() + 1
amount = principal * ((1 + (rate / 100.0)) ** years)
self.amountLabel.setText("$ {0:.2f}".format(amount))
class Settings_Misc(QWidget):
def __init__(self, parent: QWidget):
super(Settings_Misc, self).__init__(parent)
self._layout = QVBoxLayout()
self.setLayout(self._layout)
# tray icon settings
self._l_ti = QHBoxLayout()
self._lbl_ti = QLabel(self.tr("System tray icon:"), self)
self._cb_ti = QComboBox(self)
self._cb_ti.addItem(self.tr("Do not use"), QVariant("none"))
self._cb_ti.addItem(self.tr("Show"), QVariant("show"))
self._cb_ti.addItem(self.tr("Show, minimize to tray"), QVariant("show_min"))
# finalize layout
self._l_ti.addWidget(self._lbl_ti)
self._l_ti.addWidget(self._cb_ti)
self._layout.addLayout(self._l_ti)
self._layout.addStretch()
#
self.hide()
def save_to_config(self, cfg: configparser.ConfigParser):
# ensure there is a 'net' section
if "tray" not in cfg:
cfg.add_section("tray")
# tray icon settings
idx = self._cb_ti.currentIndex()
if idx >= 0:
usage = str(self._cb_ti.itemData(idx, Qt.UserRole))
cfg["tray"]["icon_usage"] = usage
logger.debug("Saved misc config")
def load_from_config(self, cfg: configparser.ConfigParser):
# defaults
usage = "none"
if "tray" in cfg:
usage = cfg["tray"]["icon_usage"]
if usage == "none":
self._cb_ti.setCurrentIndex(0)
elif usage == "show":
self._cb_ti.setCurrentIndex(1)
elif usage == "show_min":
self._cb_ti.setCurrentIndex(2)
else:
raise ValueError("Ivalid tray icon usage setting: " + usage)
class ChordNames(object):
def createWidgets(self, layout):
self.chordStyleLabel = QLabel()
self.chordStyle = QComboBox()
self.chordStyleLabel.setBuddy(self.chordStyle)
self.chordStyle.setModel(listmodel.ListModel(chordNameStyles, self.chordStyle,
display=listmodel.translate))
self.guitarFrets = QCheckBox()
box = QHBoxLayout()
box.addWidget(self.chordStyleLabel)
box.addWidget(self.chordStyle)
layout.addLayout(box)
layout.addWidget(self.guitarFrets)
def translateWidgets(self):
self.chordStyleLabel.setText(_("Chord style:"))
self.guitarFrets.setText(_("Guitar fret diagrams"))
self.guitarFrets.setToolTip(_(
"Show predefined guitar fret diagrams below the chord names "
"(LilyPond 2.12 and above)."))
self.chordStyle.model().update()
def build(self, data, builder):
p = ly.dom.ChordNames()
a = data.assign('chordNames')
ly.dom.Identifier(a.name, p)
s = ly.dom.ChordMode(a)
ly.dom.Identifier(data.globalName, s).after = 1
i = self.chordStyle.currentIndex()
if i > 0:
ly.dom.Line('\\{0}Chords'.format(
('german', 'semiGerman', 'italian', 'french')[i-1]), s)
ly.dom.LineComment(_("Chords follow here."), s)
ly.dom.BlankLine(s)
data.nodes.append(p)
if self.guitarFrets.isChecked():
f = ly.dom.FretBoards()
ly.dom.Identifier(a.name, f)
data.nodes.append(f)
data.includes.append("predefined-guitar-fretboards.ly")
class IntervalWidget(QWidget):
def __init__(self, parent=None):
super().__init__(parent)
layout = QHBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
self.spinbox = QSpinBox(self)
self.combo = QComboBox(self)
sp = self.spinbox.sizePolicy()
sp.setHorizontalStretch(1)
self.spinbox.setSizePolicy(sp)
self.spinbox.setRange(0, (1 << 31) - 1)
self.spinbox.setSingleStep(1)
self.combo.addItem('Seconds')
self.combo.addItem('Milliseconds')
layout.addWidget(self.spinbox)
layout.addWidget(self.combo)
def set_interval(self, interval):
if ('%.03f' % interval).endswith('.000'):
self.spinbox.setValue(int(interval))
self.combo.setCurrentIndex(0)
else:
self.spinbox.setValue(round(interval * 1000.0))
self.combo.setCurrentIndex(1)
def get_interval(self):
if self.combo.currentIndex() == 0:
return self.spinbox.value()
else:
return self.spinbox.value() / 1000.0
class Pressure(PluginBase):
def __init__(self, *args):
super().__init__(BrickletPressure, *args)
self.p = self.device
self.cbe_pressure = CallbackEmulator(self.p.get_pressure,
None,
self.cb_pressure,
self.increase_error_count)
self.current_pressure = CurveValueWrapper() # float, kPa
plots = [('Pressure', Qt.red, self.current_pressure, '{:.3f} kPa'.format)]
self.plot_widget = PlotWidget('Pressure [kPa]', plots, y_resolution=0.001)
self.combo_sensor = QComboBox()
self.combo_sensor.addItem('MPX5500')
self.combo_sensor.addItem('MPXV5004')
self.combo_sensor.addItem('MPX4115A')
self.combo_sensor.currentIndexChanged.connect(self.combo_sensor_changed)
self.spin_average = QSpinBox()
self.spin_average.setMinimum(1)
self.spin_average.setMaximum(50)
self.spin_average.setSingleStep(1)
self.spin_average.setValue(50)
self.spin_average.editingFinished.connect(self.spin_average_finished)
hlayout = QHBoxLayout()
hlayout.addWidget(QLabel('Sensor Type:'))
hlayout.addWidget(self.combo_sensor)
hlayout.addStretch()
hlayout.addWidget(QLabel('Moving Average Length:'))
hlayout.addWidget(self.spin_average)
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 get_sensor_type_async(self, sensor):
self.combo_sensor.setCurrentIndex(sensor)
def get_moving_average_async(self, average):
self.spin_average.setValue(average)
def start(self):
async_call(self.p.get_sensor_type, None, self.get_sensor_type_async, self.increase_error_count)
async_call(self.p.get_moving_average, None, self.get_moving_average_async, self.increase_error_count)
self.cbe_pressure.set_period(100)
self.plot_widget.stop = False
def stop(self):
self.cbe_pressure.set_period(0)
self.plot_widget.stop = True
def destroy(self):
pass
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickletPressure.DEVICE_IDENTIFIER
def cb_pressure(self, pressure):
self.current_pressure.value = pressure / 1000.0
def combo_sensor_changed(self):
self.p.set_sensor_type(self.combo_sensor.currentIndex())
def spin_average_finished(self):
self.p.set_moving_average(self.spin_average.value())
class HallEffect(PluginBase):
def __init__(self, *args):
super().__init__(BrickletHallEffect, *args)
self.hf = self.device
self.cbe_edge_count = CallbackEmulator(self.get_edge_count,
False,
self.cb_edge_count,
self.increase_error_count,
expand_result_tuple_for_callback=True)
self.current_value = CurveValueWrapper()
self.label_count = CountLabel('Count')
plots = [('Value', Qt.red, self.current_value, str)]
self.plot_widget = PlotWidget('Value', plots, extra_key_widgets=[self.label_count], update_interval=0.05)
self.plot_widget.set_fixed_y_scale(0, 1, 1, 1)
self.combo_edge_type = QComboBox()
self.combo_edge_type.addItem('Rising')
self.combo_edge_type.addItem('Falling')
self.combo_edge_type.addItem('Both')
self.combo_edge_type.currentIndexChanged.connect(self.edge_changed)
self.spin_debounce = QSpinBox()
self.spin_debounce.setMinimum(0)
self.spin_debounce.setMaximum(255)
self.spin_debounce.setValue(100)
self.spin_debounce.editingFinished.connect(self.debounce_changed)
self.button_reset = QPushButton('Reset Count')
self.button_reset.clicked.connect(self.reset_count)
hlayout = QHBoxLayout()
hlayout.addWidget(QLabel('Edge Type:'))
hlayout.addWidget(self.combo_edge_type)
hlayout.addStretch()
hlayout.addWidget(QLabel('Debounce Period [ms]:'))
hlayout.addWidget(self.spin_debounce)
hlayout.addStretch()
hlayout.addWidget(self.button_reset)
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 debounce_changed(self):
self.hf.set_edge_count_config(self.combo_edge_type.currentIndex(), self.spin_debounce.value())
def edge_changed(self, _value):
self.hf.set_edge_count_config(self.combo_edge_type.currentIndex(), self.spin_debounce.value())
def get_edge_count(self, reset):
edge_count = self.hf.get_edge_count(reset)
value = self.hf.get_value()
if reset:
edge_count = 0
return edge_count, value
def cb_edge_count(self, edge_count, value):
if value:
self.current_value.value = 1
else:
self.current_value.value = 0
self.label_count.setText(edge_count)
def get_edge_count_config_async(self, edge_type, debounce):
self.combo_edge_type.setCurrentIndex(edge_type)
self.spin_debounce.setValue(debounce)
def reset_count(self):
async_call(self.get_edge_count, True, self.cb_edge_count, self.increase_error_count,
expand_result_tuple_for_callback=True)
def start(self):
async_call(self.hf.get_edge_count_config, None, self.get_edge_count_config_async, self.increase_error_count,
expand_result_tuple_for_callback=True)
self.cbe_edge_count.set_period(50)
self.plot_widget.stop = False
def stop(self):
self.cbe_edge_count.set_period(0)
self.plot_widget.stop = True
def destroy(self):
pass
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickletHallEffect.DEVICE_IDENTIFIER
class MainWindow(QWidget):
progress_signal = pyqtSignal(object)
complete_signal = pyqtSignal(object)
error_signal = pyqtSignal(object)
def __init__(self):
super().__init__()
self.dev = None
self.progress_signal.connect(self._on_progress)
self.complete_signal.connect(self._on_complete)
self.error_signal.connect(self._on_error)
lbl_warning = QLabel(
"<font color='red'><b>Make sure jumploader is installed before you flash QMK</b></font>"
)
lbl_warning.setWordWrap(True)
btn_flash_qmk = QPushButton("Flash QMK...")
btn_flash_qmk.clicked.connect(self.on_click_flash_qmk)
lbl_help = QLabel(
"After jumploader is installed, hold Backspace while plugging in the keyboard to start in bootloader mode."
)
lbl_help.setWordWrap(True)
btn_reboot_bl = QPushButton("Reboot to Bootloader")
btn_reboot_bl.clicked.connect(self.on_click_reboot)
btn_flash_jumploader = QPushButton("Flash Jumploader")
btn_flash_jumploader.clicked.connect(self.on_click_flash_jumploader)
btn_restore_stock = QPushButton("Revert to Stock Firmware")
btn_restore_stock.clicked.connect(self.on_click_revert)
self.progress = QProgressBar()
self.progress.setRange(0, 100)
self.progress_label = QLabel("Ready")
self.combobox_devices = QComboBox()
btn_refresh_devices = QToolButton()
btn_refresh_devices.setToolButtonStyle(Qt.ToolButtonTextOnly)
btn_refresh_devices.setText("Refresh")
btn_refresh_devices.clicked.connect(self.on_click_refresh)
devices_layout = QHBoxLayout()
devices_layout.addWidget(self.combobox_devices)
devices_layout.addWidget(btn_refresh_devices)
layout_qmk = QVBoxLayout()
layout_qmk.setAlignment(Qt.AlignTop)
layout_qmk.addWidget(lbl_warning)
layout_qmk.addWidget(btn_flash_qmk)
layout_qmk.addWidget(lbl_help)
layout_stock = QVBoxLayout()
layout_stock.setAlignment(Qt.AlignTop)
layout_stock.addWidget(btn_reboot_bl)
layout_stock.addWidget(btn_flash_jumploader)
layout_stock.addWidget(btn_restore_stock)
layout_progress = QVBoxLayout()
layout_progress.addWidget(self.progress_label)
layout_progress.addWidget(self.progress)
group_qmk = QGroupBox("QMK")
group_qmk.setLayout(layout_qmk)
group_stock = QGroupBox("Stock")
group_stock.setLayout(layout_stock)
group_progress = QGroupBox("")
group_progress.setLayout(layout_progress)
group_layout = QHBoxLayout()
group_layout.addWidget(group_qmk)
group_layout.addWidget(group_stock)
layout = QVBoxLayout()
layout.addLayout(devices_layout, stretch=0)
layout.addLayout(group_layout, stretch=1)
layout.addWidget(group_progress, stretch=0)
self.setLayout(layout)
self.lockable = [
btn_flash_qmk, btn_reboot_bl, btn_flash_jumploader,
btn_restore_stock, self.combobox_devices, btn_refresh_devices
]
self.on_click_refresh()
def lock_user(self):
for obj in self.lockable:
obj.setEnabled(False)
def unlock_user(self):
self.close_dev()
for obj in self.lockable:
obj.setEnabled(True)
def close_dev(self):
if self.dev is not None:
self.dev.close()
self.dev = None
def _on_progress(self, args):
msg, progress = args
progress = int(progress * 100)
self.progress.setValue(progress)
self.progress_label.setText(msg)
def _on_complete(self, args):
self.progress.setValue(100)
self.progress_label.setText("Finished")
self.on_click_refresh()
self.unlock_user()
def _on_error(self, msg):
self.progress_label.setText("Failed")
QMessageBox.critical(window, "Error", msg)
self.unlock_user()
def on_progress(self, msg, progress):
self.progress_signal.emit([msg, progress])
def on_complete(self):
self.complete_signal.emit(None)
def on_error(self, msg):
self.error_signal.emit(msg)
def on_click_refresh(self):
self.devices = []
self.combobox_devices.clear()
for dev in hid.enumerate():
vid, pid = dev["vendor_id"], dev["product_id"]
if (vid, pid) in DEVICE_DESC:
self.combobox_devices.addItem(
"{} [{:04X}:{:04X}:{:02X}:{:02X}]".format(
DEVICE_DESC[(vid, pid)], vid, pid,
dev["interface_number"], dev["usage"]))
self.devices.append(dev)
def get_active_device(self):
idx = self.combobox_devices.currentIndex()
if idx == -1:
self._on_error("No device selected")
return None
try:
dev = hid.device()
dev.open_path(self.devices[idx]["path"])
return dev
except OSError:
self._on_error(
"Failed to open the device. You might not have sufficient permissions."
)
return None
def sanity_check_qmk_firmware(self, firmware):
# check the size so we don't trash bootloader
# (ok, we wouldn't overwrite it anyway as it's checked again in cmd_flash)
if len(firmware) > QMK_MAX_FIRMWARE:
self._on_error(
"Firmware is too large: 0x{:X} max allowed is 0x{:X}".format(
len(firmware), QMK_MAX_FIRMWARE))
return False
if len(firmware) < 0x100:
self._on_error("Firmware is too small")
return False
firmware_valid = True
# check stack pointer is valid and that first 3 vectors have bit0 set
sp, *vecs = struct.unpack("<IIII", firmware[0:16])
if sp < 0x20000000 or sp > 0x20000800 or vecs[0] & 1 != 1 or vecs[
1] & 1 != 1 or vecs[2] & 1 != 1:
self._on_error("Firmware appears to be corrupted")
return False
return True
def on_click_flash_qmk(self):
self.dev = self.get_active_device()
if not self.dev:
return
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
filename = QFileDialog.getOpenFileName(None,
"Select firmware to flash",
"",
"Firmware Files (*.bin)",
options=options)[0]
if not filename:
self.close_dev()
return
with open(filename, "rb") as inf:
firmware = inf.read()
if not self.sanity_check_qmk_firmware(firmware):
self.close_dev()
return
self.lock_user()
threading.Thread(target=lambda: cmd_flash(
self.dev, QMK_OFFSET, firmware, self.on_progress, self.on_complete,
self.on_error)).start()
def on_click_reboot(self):
self.dev = self.get_active_device()
if not self.dev:
return
self.lock_user()
threading.Thread(
target=lambda: cmd_reboot(self.dev, self.on_progress, self.
on_complete, self.on_error)).start()
def dangerous_flash(self, path):
reply = QMessageBox.question(
self, "Warning",
"This is a potentially dangerous operation, are you sure you want to continue?",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if reply != QMessageBox.Yes:
return
self.dev = self.get_active_device()
if not self.dev:
return
with open(path, "rb") as inf:
firmware = inf.read()
self.lock_user()
threading.Thread(
target=lambda: cmd_flash(self.dev, 0, firmware, self.on_progress,
self.on_complete, self.on_error)).start()
def on_click_revert(self):
self.dangerous_flash(appctxt.get_resource("stock-firmware.bin"))
def on_click_flash_jumploader(self):
self.dangerous_flash(appctxt.get_resource("jumploader.bin"))
class InboundVmessPanel(QWidget):
def __init__(self):
super().__init__()
self.inboundVmessJSONFile = {
"clients": [
{
"id": "27848739-7e62-4138-9fd3-098a63964b6b",
"level": 10,
"alterId": 30,
"email": "*****@*****.**"
}
],
"default": {
"level": 10,
"alterId": 30
},
"detour": {
"to": "tag_to_detour"
},
"disableInsecureEncryption": False
}
self.translate = QCoreApplication.translate
self.labelUserVmessPanel = (
self.translate("InboundVmessPanel", "Email"),
self.translate("InboundVmessPanel", "Level"),
self.translate("InboundVmessPanel", "AlterID"),
self.translate("InboundVmessPanel", "UUID"))
def createVmessSettingPanel(self):
labelDetourTo = QLabel(
self.translate("InboundVmessPanel", "Detour To InboundDetour: "), self)
self.comboBoxInVmessInboundTags = QComboBox()
self.checkBoxdisableInsecureEncryption = QCheckBox(
self.translate("InboundVmessPanel", "Disable Insecure Encryption"), self)
self.checkBoxdisableInsecureEncryption.setChecked(False)
labelEmail = QLabel(
self.translate("InboundVmessPanel", "Email: "), self)
self.lineEditInVmessMail = QLineEdit()
labelUIID = QLabel(
self.translate("InboundVmessPanel", "UUID: "), self)
self.lineEditInVmessUUID = QLineEdit()
labelAlterID = QLabel(
self.translate("InboundVmessPanel", "AlterID: "), self)
labelLevel = QLabel(
self.translate("InboundVmessPanel", "Level: "), self)
self.btnInVmessGenerate = QPushButton(
self.translate("InboundVmessPanel", "Generate UUID"), self)
self.btnInVmessChange = QPushButton(
self.translate("InboundVmessPanel", "Modify"), self)
self.btnInVmessClear = QPushButton(
self.translate("InboundVmessPanel", "Clear"), self)
self.btnInVmessAdd = QPushButton(
self.translate("InboundVmessPanel", "Add"), self)
self.btnInVmessDelete = QPushButton(
self.translate("InboundVmessPanel", "Delete"), self)
self.spinBoxInVmessLevel = QSpinBox()
self.spinBoxInVmessAlterID = QSpinBox()
self.spinBoxInVmessAlterID.setRange(0, 65535)
self.spinBoxInVmessLevel.setRange(0, 65535)
self.spinBoxInVmessLevel.setValue(10)
self.spinBoxInVmessAlterID.setValue(30)
self.lineEditInVmessUUID.setInputMask("HHHHHHHH-HHHH-HHHH-HHHH-HHHHHHHHHHHH; ")
self.comboBoxInVmessInboundTags.setView(QListView())
#self.comboBoxInVmessInboundTags.setStyleSheet("QComboBox {min-width: 128px; }" "QComboBox QAbstractItemView::item {min-width: 128px; }")
hboxDetourTo = QHBoxLayout()
hboxDetourTo.addWidget(labelDetourTo)
hboxDetourTo.addWidget(self.comboBoxInVmessInboundTags)
#hboxDetourTo.addStretch()
hboxID = QHBoxLayout()
hboxID.addWidget(labelUIID)
hboxID.addWidget(self.lineEditInVmessUUID)
hboxID.addWidget(self.btnInVmessGenerate)
hboxLevel = QHBoxLayout()
hboxLevel.addWidget(labelLevel)
hboxLevel.addWidget(self.spinBoxInVmessLevel)
hboxLevel.addWidget(labelAlterID)
hboxLevel.addWidget(self.spinBoxInVmessAlterID)
hboxLevel.addStretch()
hboxEmail = QHBoxLayout()
hboxEmail.addWidget(labelEmail)
hboxEmail.addWidget(self.lineEditInVmessMail)
vboxInVmessBtn = QVBoxLayout()
vboxInVmessBtn.addStretch()
vboxInVmessBtn.addWidget(self.btnInVmessAdd)
vboxInVmessBtn.addWidget(self.btnInVmessClear)
vboxInVmessBtn.addWidget(self.btnInVmessChange)
vboxInVmessBtn.addWidget(self.btnInVmessDelete)
vboxSetting = QVBoxLayout()
vboxSetting.addLayout(hboxID)
vboxSetting.addLayout(hboxLevel)
vboxSetting.addLayout(hboxEmail)
self.tableWidgetInVmessUser = tableWidgetUser = QTableWidget(self)
tableWidgetUser.setRowCount(0)
tableWidgetUser.setColumnCount(4)
tableWidgetUser.setHorizontalHeaderLabels(self.labelUserVmessPanel)
tableWidgetUser.setSelectionMode(QAbstractItemView.SingleSelection)
tableWidgetUser.setSelectionBehavior(QAbstractItemView.SelectRows)
tableWidgetUser.setEditTriggers(QAbstractItemView.NoEditTriggers)
tableWidgetUser.horizontalHeader().setStretchLastSection(True)
hboxTableWidgetUser = QHBoxLayout()
hboxTableWidgetUser.addWidget(tableWidgetUser)
hboxTableWidgetUser.addLayout(vboxInVmessBtn)
vboxSetting.addLayout(hboxTableWidgetUser)
self.groupBoxClientsSetting = groupBoxClientsSetting = QGroupBox(
self.translate("InboundVmessPanel", "Clients: "), self)
groupBoxClientsSetting.setLayout(vboxSetting)
groupBoxClientsSetting.setCheckable(True)
groupBoxClientsSetting.setChecked(True)
vboxVmessPanel = QVBoxLayout()
vboxVmessPanel.addLayout(hboxDetourTo)
vboxVmessPanel.addWidget(self.checkBoxdisableInsecureEncryption)
vboxVmessPanel.addWidget(self.createVmessDefaultSettingPanel())
vboxVmessPanel.addWidget(groupBoxClientsSetting)
if (v2rayshellDebug):
self.__debugBtn = QPushButton("__debugTest", self)
vboxVmessPanel.addWidget(self.__debugBtn)
self.__debugBtn.clicked.connect(self.__debugTest)
self.settingInboundVmessPanelFromJSONFile(self.inboundVmessJSONFile, True)
groupBoxVmessPanel = QGroupBox(
self.translate("InboundVmessPanel", "Vmess"), self)
groupBoxVmessPanel.setLayout(vboxVmessPanel)
self.createVmessPanelSignals()
return groupBoxVmessPanel
def createVmessDefaultSettingPanel(self):
labelDefaultLevel = QLabel(
self.translate("InboundVmessPanel", "Level: "), self)
self.spinBoxDefaultLevel = QSpinBox()
labelAlterID = QLabel(
self.translate("InboundVmessPanel", "AlterID: "), self)
self.spinBoxDefaultAlterID = QSpinBox()
self.spinBoxDefaultLevel.setRange(0, 100)
self.spinBoxDefaultLevel.setValue(10)
self.spinBoxDefaultAlterID.setRange(0, 65535)
self.spinBoxDefaultAlterID.setValue(30)
self.groupBoxDefault = groupBoxDefault = QGroupBox(
self.translate("InboundVmessPanel", "Default: "), self)
hboxDefault = QHBoxLayout()
hboxDefault.addWidget(labelDefaultLevel)
hboxDefault.addWidget(self.spinBoxDefaultLevel)
hboxDefault.addWidget(labelAlterID)
hboxDefault.addWidget(self.spinBoxDefaultAlterID)
hboxDefault.addStretch()
groupBoxDefault.setCheckable(True)
groupBoxDefault.setChecked(False)
groupBoxDefault.setLayout(hboxDefault)
return groupBoxDefault
def createVmessPanelSignals(self):
self.btnInVmessClear.clicked.connect(self.onbtnInVmessClear)
self.btnInVmessGenerate.clicked.connect(self.onbtnInVmessGenerate)
self.btnInVmessAdd.clicked.connect(self.onbtnInVmessAdd)
self.tableWidgetInVmessUser.itemSelectionChanged.connect(
self.ontableWidgetInVmessUserSelectionChanged)
self.btnInVmessDelete.clicked.connect(self.onbtnInVmessDelete)
self.btnInVmessChange.clicked.connect(self.onbtnInVmessChange)
def onbtnInVmessChange(self):
row = self.tableWidgetInVmessUser.currentRow()
self.tableWidgetInVmessUser.setItem(
row, 0, QTableWidgetItem(self.lineEditInVmessMail.text()))
self.tableWidgetInVmessUser.setItem(
row, 3, QTableWidgetItem(self.lineEditInVmessUUID.text()))
self.tableWidgetInVmessUser.setItem(
row, 2, QTableWidgetItem(self.spinBoxInVmessAlterID.text()))
self.tableWidgetInVmessUser.setItem(
row, 1, QTableWidgetItem(self.spinBoxInVmessLevel.text()))
self.tableWidgetInVmessUser.resizeColumnsToContents()
def onbtnInVmessDelete(self):
self.onbtnInVmessClear()
self.tableWidgetInVmessUser.removeRow(self.tableWidgetInVmessUser.currentRow())
def ontableWidgetInVmessUserSelectionChanged(self):
row = self.tableWidgetInVmessUser.currentRow()
mail = self.tableWidgetInVmessUser.item(row, 0)
level = self.tableWidgetInVmessUser.item(row, 1)
alterID = self.tableWidgetInVmessUser.item(row, 2)
uuid = self.tableWidgetInVmessUser.item(row, 3)
if (uuid):
self.lineEditInVmessUUID.setText(uuid.text())
else:
self.lineEditInVmessUUID.clear()
if (mail):
self.lineEditInVmessMail.setText(mail.text())
else:
self.lineEditInVmessMail.clear()
if (level):
try: self.spinBoxInVmessLevel.setValue(int(level.text()))
except Exception: pass
else:
self.spinBoxInVmessLevel.setValue(10)
if (alterID):
try:self.spinBoxInVmessAlterID.setValue(int(alterID.text()))
except Exception: pass
else:
self.spinBoxInVmessAlterID.setValue(30)
def onbtnInVmessAdd(self):
boolUUID = self.validateUUID4("".join(self.lineEditInVmessUUID.text().split("-")))
if (self.lineEditInVmessMail.text() == "" or (boolUUID == False)): return
row = self.tableWidgetInVmessUser.rowCount()
self.tableWidgetInVmessUser.setRowCount(row+1) ### DO NOT use ++row, row maybe is ZERO
self.tableWidgetInVmessUser.setItem(
row, 3, QTableWidgetItem(self.lineEditInVmessUUID.text()))
self.tableWidgetInVmessUser.setItem(
row, 2, QTableWidgetItem(self.spinBoxInVmessAlterID.text()))
self.tableWidgetInVmessUser.setItem(
row, 1, QTableWidgetItem(self.spinBoxInVmessLevel.text()))
self.tableWidgetInVmessUser.setItem(
row, 0, QTableWidgetItem(self.lineEditInVmessMail.text()))
self.tableWidgetInVmessUser.resizeColumnsToContents()
self.onbtnInVmessClear()
def onbtnInVmessGenerate(self):
self.lineEditInVmessUUID.setText(self.createUUID())
def onbtnInVmessClear(self):
self.lineEditInVmessUUID.clear()
self.spinBoxInVmessAlterID.setValue(30)
self.spinBoxInVmessLevel.setValue(10)
self.lineEditInVmessMail.clear()
def settingInboundVmessPanelFromJSONFile(self, inboundVmessJSONFile = {}, openFromJSONFile = False):
logbook.setisOpenJSONFile(openFromJSONFile)
self.tableWidgetInVmessUser.setRowCount(0)
detour = True; defaultLevelAlterID = True; client = True
if (not inboundVmessJSONFile): inboundVmessJSONFile ={}
try:
inboundVmessJSONFile["detour"]
inboundVmessJSONFile["detour"]["to"]
except KeyError as e:
logbook.writeLog("InboundVmess", "KeyError", e)
inboundVmessJSONFile["detour"] = {}
inboundVmessJSONFile["detour"]["to"] = ""
detour = False
try:
inboundVmessJSONFile["disableInsecureEncryption"]
except KeyError as e:
logbook.writeLog("InboundVmess", "KeyError", e)
inboundVmessJSONFile["disableInsecureEncryption"] = False
try:
inboundVmessJSONFile["default"]
except KeyError as e:
logbook.writeLog("InboundVmess", "KeyError", e)
inboundVmessJSONFile["default"] = {}
inboundVmessJSONFile["default"]["level"] = 10
inboundVmessJSONFile["default"]["alterId"] = 30
defaultLevelAlterID = False
def settingdefaultLevelAlterID(level = 10, alterid = 30, default = True):
self.spinBoxDefaultLevel.setValue(level)
self.spinBoxDefaultAlterID.setValue(alterid)
self.groupBoxDefault.setChecked(default)
try: self.treasureChest.addLevel(self.spinBoxDefaultLevel.value())
except Exception: pass
try:
inboundVmessJSONFile["clients"]
except KeyError as e:
logbook.writeLog("InboundVmess", "KeyError", e)
inboundVmessJSONFile["clients"] = []
client = False
if (inboundVmessJSONFile["disableInsecureEncryption"]):
self.checkBoxdisableInsecureEncryption.setChecked(True)
if (detour):
self.comboBoxInVmessInboundTags.insertItem(self.comboBoxInVmessInboundTags.currentIndex(),
str(inboundVmessJSONFile["detour"]["to"]))
self.comboBoxInVmessInboundTags.setCurrentText(str(inboundVmessJSONFile["detour"]["to"]))
if (defaultLevelAlterID):
try:
settingdefaultLevelAlterID(int(inboundVmessJSONFile["default"]["level"]),
int(inboundVmessJSONFile["default"]["alterId"]),
True)
except KeyError as e:
logbook.writeLog("InboundVmess Default Level and AlterID", "KeyError", e)
settingdefaultLevelAlterID()
except (TypeError, ValueError) as e:
logbook.writeLog("InboundVmess Default Level and AlterID", "ValueError or TypeError", e)
settingdefaultLevelAlterID()
elif (not defaultLevelAlterID):
settingdefaultLevelAlterID(default = False)
if (client):
self.groupBoxClientsSetting.setChecked(True)
clientsNumber = len(inboundVmessJSONFile["clients"])
clients = inboundVmessJSONFile["clients"]
if (clientsNumber > 0):
self.tableWidgetInVmessUser.setRowCount(clientsNumber)
for i in range(clientsNumber):
try:
email = QTableWidgetItem(str(clients[i]["email"]))
except Exception: email = QTableWidgetItem("")
try:
level = QTableWidgetItem(str(clients[i]["level"]))
except Exception: level = QTableWidgetItem("")
try:
alterID = QTableWidgetItem(str(clients[i]["alterId"]))
except Exception: alterID = QTableWidgetItem("")
try:
uuidStr = QTableWidgetItem(str(clients[i]["id"]))
except Exception: uuidStr = QTableWidgetItem("")
self.tableWidgetInVmessUser.setItem(i, 0, email)
self.tableWidgetInVmessUser.setItem(i, 1, level)
self.tableWidgetInVmessUser.setItem(i, 2, alterID)
self.tableWidgetInVmessUser.setItem(i, 3, uuidStr)
self.tableWidgetInVmessUser.resizeColumnsToContents()
try:self.treasureChest.addLevel(clients[i]["level"])
except Exception: pass
try: self.treasureChest.addEmail(clients[i]["email"])
except Exception: pass
else:
self.groupBoxClientsSetting.setChecked(False)
else:
self.groupBoxClientsSetting.setChecked(False)
def createInboundVmessJSONFile(self):
inboundVmessJSONFile = {}
inboundVmessJSONFile["clients"] = []
inboundVmessJSONFile["default"] = {}
inboundVmessJSONFile["detour"] = {}
clientsNumber = self.tableWidgetInVmessUser.rowCount()
if (clientsNumber > 0 and self.groupBoxClientsSetting.isChecked()):
clients = []
for i in range(0, clientsNumber):
client = {}
email = self.tableWidgetInVmessUser.item(i, 0)
level = self.tableWidgetInVmessUser.item(i, 1)
alterId = self.tableWidgetInVmessUser.item(i, 2)
uuid = self.tableWidgetInVmessUser.item(i, 3)
if (email and level and alterId and uuid):
client["id"] = uuid.text()
client["level"] = int(level.text())
client["alterId"] = int(alterId.text())
client["email"] = email.text()
try:
self.treasureChest.addLevel(client["level"])
self.treasureChest.addEmail(client["email"])
except Exception:
pass
clients.append(copy.deepcopy(client))
inboundVmessJSONFile["clients"] = copy.deepcopy(clients)
else:
inboundVmessJSONFile["clients"] = []
if (self.groupBoxDefault.isChecked()):
inboundVmessJSONFile["default"]["level"] = self.spinBoxDefaultLevel.value()
inboundVmessJSONFile["default"]["alterId"] = self.spinBoxDefaultAlterID.value()
try:
self.treasureChest.addLevel(self.spinBoxDefaultLevel.value())
except Exception:
pass
else:
del inboundVmessJSONFile["default"]
InboundTags = self.comboBoxInVmessInboundTags.currentText()
if (InboundTags != ""):
inboundVmessJSONFile["detour"]["to"] = InboundTags
else:
del inboundVmessJSONFile["detour"]
if (self.checkBoxdisableInsecureEncryption.isChecked()):
inboundVmessJSONFile["disableInsecureEncryption"] = True
else:
inboundVmessJSONFile["disableInsecureEncryption"] = False
return inboundVmessJSONFile
def clearinboundVmessPanel(self):
self.tableWidgetInVmessUser.setRowCount(0)
self.groupBoxClientsSetting.setChecked(False)
self.groupBoxDefault.setChecked(False)
self.spinBoxDefaultAlterID.setValue(30)
self.spinBoxDefaultLevel.setValue(10)
self.spinBoxInVmessAlterID.setValue(30)
self.spinBoxInVmessLevel.setValue(10)
self.comboBoxInVmessInboundTags.setCurrentIndex(0)
self.lineEditInVmessMail.clear()
self.lineEditInVmessUUID.clear()
self.checkBoxdisableInsecureEncryption.setChecked(False)
def createUUID(self):
#TODO use QT UUID generate
return str(uuid.uuid4())
def validateUUID4(self, uuidString):
try:
uuid.UUID(uuidString, version = 4)
except ValueError:
return False
return True
def __debugTest(self):
import json
print(json.dumps(self.createInboundVmessJSONFile(), indent = 4, sort_keys = False))
class example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.btn = QPushButton('City', self)
self.btn.move(20, 20)
self.btn.clicked.connect(self.showdialog)
self.le = QLineEdit(self)
self.le.move(250, 22)
self.btn1 = QPushButton('Locality', self)
self.btn1.move(20, 50)
self.btn1.clicked.connect(self.showdialog1)
self.le1 = QLineEdit(self)
self.le1.move(250, 52)
self.lbl = QLabel('Output file type: ', self)
self.lbl.move(20, 80)
self.combo = QComboBox(self)
self.combo.addItems(["Excel", "JSON", "CSV"])
self.combo.move(250, 82)
self.combo1 = QComboBox(self)
self.combo1.addItems(["Buy", "Rent"])
self.combo1.move(330, 82)
self.btn2 = QPushButton('Convert', self)
self.btn2.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btn2.setDisabled(True)
self.btn2.move(300, 120)
self.btn2.clicked.connect(self.showdialog2)
self.btn3 = QPushButton('MagicBricks', self)
self.btn3.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btn3.move(20, 120)
self.btn3.clicked.connect(self.processor1)
self.btn4 = QPushButton('99Acres', self)
self.btn4.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btn4.move(150, 120)
self.btn4.clicked.connect(self.processor2)
self.lbl1 = QLabel(
' ',
self)
self.lbl1.move(220, 160)
self.setGeometry(500, 500, 500, 200)
self.setWindowTitle('Data Scraper')
self.show()
def showdialog(self):
text, ok = QInputDialog.getText(
self, 'City', "Which city's data are you looking for?")
if ok:
self.le.setText(str(text))
def showdialog1(self):
text, ok = QInputDialog.getText(self, 'DataFrame', 'Which locality?')
if ok:
self.le1.setText(str(text))
def showdialog2(self):
text, ok = QInputDialog.getText(
self, 'address', 'Address of the output file with file name?')
if ok:
if self.combo.currentIndex() == 0:
address = text + '.xls'
if m == 0:
df.to_excel(address)
else:
df1.to_excel(address)
self.lbl1.setText("saved as Excel file!")
elif self.combo.currentIndex() == 1:
address = text + '.json'
if m == 0:
df.to_json(address)
else:
df1.to_json(address)
self.lbl1.setText("saved as JSON file!")
else:
address = text + '.csv'
if m == 0:
df.to_csv(address)
else:
df1.to_csv(address)
self.lbl1.setText("saved as CSV file!")
def processor1(self):
global df
types = [
"Multistorey-Apartment", "Builder-Floor-Apartment", "Penthouse",
"Studio-Apartment", "Residential-House", "Villa"
]
driver = webdriver.Firefox()
for typeh in types:
if self.combo1.currentIndex() == 1:
driver.get(
"http://www.magicbricks.com/property-for-rent/residential-real-estate?proptype="
+ typeh + "&Locality=" +
(self.le1.text()).replace(" ", "-") + "&cityName=" +
self.le.text())
else:
driver.get(
"http://www.magicbricks.com/property-for-sale/residential-real-estate?proptype="
+ typeh + "&Locality=" +
(self.le1.text()).replace(" ", "-") + "&cityName=" +
self.le.text())
end = 0
first = 1
lastHeight = driver.execute_script(
"return document.body.scrollHeight")
while True:
driver.execute_script(
"window.scrollTo(0, document.body.scrollHeight);")
time.sleep(2)
newHeight = driver.execute_script(
"return document.body.scrollHeight")
if newHeight == lastHeight:
break
lastHeight = newHeight
self.lbl1.setText("Scrolling")
self.lbl1.setText("End of scroll")
soup = BeautifulSoup(driver.page_source)
if self.combo1.currentIndex() == 1:
samples = soup.find_all(
"div",
"srpBlockListRow srpRentListRow srcShadow property-sticky-link animDef "
)
else:
samples = soup.find_all("div", "SRCard")
try:
page = driver.find_element_by_class_name(
"pageNos").find_elements_by_tag_name("a")[-1]
if page.get_attribute("class") == "toc":
page.click()
first = 0
time.sleep(10)
driver.execute_script(
"window.scrollTo(0, document.body.scrollHeight);")
else:
first = 0
end = 1
except NoSuchElementException:
first = 0
end = 1
for sample in samples:
project = sample.find_all("input")[12]["value"]
area = sample.find_all("span", "localityFirst")[0].contents[0]
if self.combo1.currentIndex() == 0:
latitude = sample.find_all("div",
"iconMap")[0].a["data-link"]
no = latitude.find("lat")
latitude = latitude[no + 4:no + 13]
longitude = sample.find_all("div",
"iconMap")[0].a["data-link"]
no = longitude.find("longt")
longitude = longitude[no + 6:no + 15]
else:
latitude = sample.find_all(
"a",
"Rent-SeeOnMapLink stop-propagation")[0]["data-link"]
no = latitude.find("lat")
latitude = latitude[no + 4:no + 13]
longitude = sample.find_all(
"a",
"Rent-SeeOnMapLink stop-propagation")[0]["data-link"]
no = longitude.find("longt")
longitude = longitude[no + 6:no + 15]
price = sample.find_all("span", "proPriceField")[0].contents[0]
bedroom = sample.find_all(
"a", "property-sticky-link")[0].input["value"]
try:
if self.combo1.currentIndex() == 0:
sqft = sample.find_all("b", "areaValue")[0].contents[0]
else:
sqft = sample.find_all("input")[18]["value"]
except IndexError:
sqft = "not available"
try:
sqft_price = sample.find_all(
"span", "sqrPriceField")[0].contents[1]
except IndexError:
sqft_price = "not available"
furnished = sample.find_all("input")[5]["value"]
sell_rent = sample.find_all("input")[0]["value"]
contact = sample.find_all("input")[13]["value"]
if (df == np.array([
area, bedroom, contact, furnished, latitude, longitude,
price, project, sell_rent, sqft, sqft_price, typeh
])).all(1).any():
self.lbl1.setText("rejected")
else:
self.lbl1.setText("added row no " + str(len(df)))
df.loc[len(df)] = [
area, bedroom, contact, furnished, latitude, longitude,
price, project, sell_rent, sqft, sqft_price, typeh
]
try:
page = driver.find_element_by_class_name(
"pageNos").find_elements_by_tag_name("a")[-1]
time.sleep(10)
while (end == 0):
if first == 1:
driver.find_element_by_class_name(
"pageNos").find_elements_by_tag_name(
"a")[-1].click()
time.sleep(10)
lastHeight = driver.execute_script(
"return document.body.scrollHeight")
while True:
driver.execute_script(
"window.scrollTo(0, document.body.scrollHeight);")
time.sleep(2)
newHeight = driver.execute_script(
"return document.body.scrollHeight")
if newHeight == lastHeight:
break
lastHeight = newHeight
self.lbl1.setText("Scrolling")
self.lbl1.setText("End of scroll")
soup = BeautifulSoup(driver.page_source)
if self.combo1.currentIndex() == 1:
samples = soup.find_all(
"div",
"srpBlockListRow srpRentListRow srcShadow property-sticky-link animDef "
)
else:
samples = soup.find_all("div", "SRCard")
try:
page = driver.find_element_by_class_name(
"pageNos").find_elements_by_tag_name("a")[-1]
if page.get_attribute("class") == "toc":
page.click()
first = 0
time.sleep(10)
driver.execute_script(
"window.scrollTo(0, document.body.scrollHeight);"
)
else:
first = 0
end = 1
except NoSuchElementException:
first = 0
end = 1
for sample in samples:
project = sample.find_all("input")[12]["value"]
area = sample.find_all("span",
"localityFirst")[0].contents[0]
if self.combo1.currentIndex() == 0:
latitude = sample.find_all(
"div", "iconMap")[0].a["data-link"]
no = latitude.find("lat")
latitude = latitude[no + 4:no + 13]
longitude = sample.find_all(
"div", "iconMap")[0].a["data-link"]
no = longitude.find("longt")
longitude = longitude[no + 6:no + 15]
else:
latitude = sample.find_all(
"a", "Rent-SeeOnMapLink stop-propagation"
)[0]["data-link"]
no = latitude.find("lat")
latitude = latitude[no + 4:no + 13]
longitude = sample.find_all(
"a", "Rent-SeeOnMapLink stop-propagation"
)[0]["data-link"]
no = longitude.find("longt")
longitude = longitude[no + 6:no + 15]
price = sample.find_all("span",
"proPriceField")[0].contents[0]
bedroom = sample.find_all(
"a", "property-sticky-link")[0].input["value"]
try:
if self.combo1.currentIndex() == 0:
sqft = sample.find_all(
"b", "areaValue")[0].contents[0]
else:
sqft = sample.find_all("input")[18]["value"]
except IndexError:
sqft = "not available"
try:
sqft_price = sample.find_all(
"span", "sqrPriceField")[0].contents[1]
except IndexError:
sqft_price = "not available"
furnished = sample.find_all("input")[5]["value"]
sell_rent = sample.find_all("input")[0]["value"]
contact = sample.find_all("input")[13]["value"]
if (df == np.array([
area, bedroom, contact, furnished, latitude,
longitude, price, project, sell_rent, sqft,
sqft_price, typeh
])).all(1).any():
self.lbl1.setText("rejected")
else:
self.lbl1.setText("added row no " + str(len(df)))
df.loc[len(df)] = [
area, bedroom, contact, furnished, latitude,
longitude, price, project, sell_rent, sqft,
sqft_price, typeh
]
except NoSuchElementException:
continue
self.btn2.setEnabled(True)
self.lbl1.setText("Data is extracted!")
global m
m = 0
driver.quit()
def processor2(self):
global df1
driver = webdriver.Firefox()
actions = ActionChains(driver)
driver.get("http://www.99acres.com/")
if self.combo1.currentIndex() == 1:
driver.find_element_by_id("ResRentTab").click()
end = 0
driver.find_element_by_id("keyword").clear()
time.sleep(5)
actions.send_keys(self.le1.text() + ", " + self.le.text())
actions.perform()
time.sleep(5)
driver.find_element_by_id(
"suggestions_custom").find_element_by_tag_name("a").click()
driver.find_element_by_id("submit_query").click()
time.sleep(10)
soup = BeautifulSoup(driver.page_source)
samples = soup.find_all("div", "srpWrap")
try:
page = driver.find_element_by_class_name(
"pgdiv").find_elements_by_tag_name("a")[-1]
if page.get_attribute("class") == "pgselActive":
page.click()
else:
end = 1
except NoSuchElementException:
end = 1
for sample in samples:
project = sample.find_all("i", "uline")[0]["data-bldname"]
try:
area = sample.find_all(
"meta", itemprop="addressLocality")[0]["content"]
except IndexError:
area = "Malleshwaram"
try:
typeh = sample.find_all("meta", itemprop="name")[0]["content"]
except IndexError:
typeh = "unknown"
latitude = sample.find_all("i", "uline")[0]["data-maplatlngzm"]
latitude = latitude[0:9]
longitude = sample.find_all("i", "uline")[0]["data-maplatlngzm"]
longitude = longitude[24:34]
price = str(sample.find_all("i", "uline")[0]["data-price"])
no = price.find(",")
price = price[:no]
bedroom = sample.find_all("i", "uline")[0]["data-bedrm"]
sqft = sample.find_all("i", "uline")[0]["data-area"]
no = sqft.find(",")
no1 = sqft[no + 1:].find(",")
sqft = sqft[no + 1:no1 + no + 1]
sqft_price = (str(
sample.find_all("div",
"srpDataWrap")[0].span.contents[-1])).replace(
"<b>", "").replace("</b>", "")
a = sample.find_all("div", "srpDataWrap")[0].contents
for b in a:
if "Highlights" in str(b):
b = str(b)
no = b.find("</")
no1 = (b[no + 2:]).find("</")
sell_rent = b[no + 14:no1 + no + 2]
sell_rent = sell_rent.replace(">", "")
no = sell_rent.find("x")
sell_rent = sell_rent[:no]
contact = sample.find_all(
"a", "srpBlue f13 mr10 lf cntClk")[0]["data-cl"]
try:
array = np.array([
area, bedroom, contact, latitude, longitude, price,
project, sell_rent, sqft, sqft_price, typeh
])
except ValueError:
pass
if (df1 == array).all(1).any():
self.lbl1.setText("rejected")
else:
self.lbl1.setText("added row no " + str(len(df)))
df1.loc[len(df1)] = [
area, bedroom, contact, latitude, longitude, price,
project, sell_rent, sqft, sqft_price, typeh
]
try:
while (end == 0):
time.sleep(10)
soup = BeautifulSoup(driver.page_source)
samples = soup.find_all("div", "srpWrap")
try:
page = driver.find_element_by_class_name(
"pgdiv").find_elements_by_tag_name("a")[-1]
if page.get_attribute("class") == "pgselActive":
page.click()
else:
end = 1
except NoSuchElementException:
end = 1
for sample in samples:
project = sample.find_all("i", "uline")[0]["data-bldname"]
try:
area = sample.find_all(
"meta", itemprop="addressLocality")[0]["content"]
except IndexError:
area = "Malleshwaram"
try:
typeh = sample.find_all("meta",
itemprop="name")[0]["content"]
except IndexError:
typeh = "unknown"
latitude = sample.find_all("i",
"uline")[0]["data-maplatlngzm"]
latitude = latitude[0:9]
longitude = sample.find_all("i",
"uline")[0]["data-maplatlngzm"]
longitude = longitude[24:34]
price = str(sample.find_all("i", "uline")[0]["data-price"])
no = price.find(",")
price = price[:no]
bedroom = sample.find_all("i", "uline")[0]["data-bedrm"]
sqft = sample.find_all("i", "uline")[0]["data-area"]
no = sqft.find(",")
no1 = sqft[no + 1:].find(",")
sqft = sqft[no + 1:no1 + no + 1]
sqft_price = (str(
sample.find_all(
"div",
"srpDataWrap")[0].span.contents[-1])).replace(
"<b>", "").replace("</b>", "")
a = sample.find_all("div", "srpDataWrap")[0].contents
for b in a:
if "Highlights" in str(b):
b = str(b)
no = b.find("</")
no1 = (b[no + 2:]).find("</")
sell_rent = b[no + 13:no1 + no + 2]
sell_rent = sell_rent.replace(">", "")
no = sell_rent.find("x")
sell_rent = sell_rent[:no]
contact = sample.find_all(
"a", "srpBlue f13 mr10 lf cntClk")[0]["data-cl"]
try:
array = np.array([
area, bedroom, contact, latitude, longitude, price,
project, sell_rent, sqft, sqft_price, typeh
])
except ValueError:
pass
if (df1 == array).all(1).any():
self.lbl1.setText("rejected")
else:
self.lbl1.setText("added row no " + str(len(df)))
df1.loc[len(df1)] = [
area, bedroom, contact, latitude, longitude, price,
project, sell_rent, sqft, sqft_price, typeh
]
except NoSuchElementException:
pass
self.btn2.setEnabled(True)
self.lbl1.setText("Data is extracted!")
global m
m = 1
driver.quit()
class MainWindow(QMainWindow):
"""Main window class."""
def __init__(self, parent=None):
"""Init class."""
super(MainWindow, self).__init__()
QNetworkProxyFactory.setUseSystemConfiguration(True)
self.statusBar().showMessage(__doc__ + get_nuitka_version())
self.setWindowTitle(__doc__.strip().capitalize())
self.setMinimumSize(480, 400)
self.setMaximumSize(1024, 800)
self.resize(self.minimumSize())
self.setWindowIcon(QIcon.fromTheme("python"))
self.center()
QShortcut("Ctrl+q", self, activated=lambda: self.close())
self.menuBar().addMenu("&File").addAction("Exit", lambda: self.close())
windowMenu = self.menuBar().addMenu("&Window")
windowMenu.addAction("Minimize", lambda: self.showMinimized())
windowMenu.addAction("Maximize", lambda: self.showMaximized())
windowMenu.addAction("Restore", lambda: self.showNormal())
windowMenu.addAction("FullScreen", lambda: self.showFullScreen())
windowMenu.addAction("Center", lambda: self.center())
windowMenu.addAction("Top-Left", lambda: self.move(0, 0))
windowMenu.addAction("To Mouse", lambda: self.move_to_mouse_position())
windowMenu.addSeparator()
windowMenu.addAction(
"Increase size", lambda:
self.resize(self.size().width() * 1.4, self.size().height() * 1.4))
windowMenu.addAction("Decrease size", lambda: self.resize(
self.size().width() // 1.4, self.size().height() // 1.4))
windowMenu.addAction("Minimum size", lambda:
self.resize(self.minimumSize()))
windowMenu.addAction("Maximum size", lambda:
self.resize(self.maximumSize()))
windowMenu.addAction("Horizontal Wide", lambda: self.resize(
self.maximumSize().width(), self.minimumSize().height()))
windowMenu.addAction("Vertical Tall", lambda: self.resize(
self.minimumSize().width(), self.maximumSize().height()))
windowMenu.addSeparator()
windowMenu.addAction("Disable Resize", lambda:
self.setFixedSize(self.size()))
windowMenu.addAction("Set Interface Font...", lambda:
self.setFont(QFontDialog.getFont()[0]))
windowMenu.addAction(
"Load .qss Skin", lambda: self.setStyleSheet(self.skin()))
helpMenu = self.menuBar().addMenu("&Help")
helpMenu.addAction("About Qt 5", lambda: QMessageBox.aboutQt(self))
helpMenu.addAction("About Python 3",
lambda: open_new_tab('https://www.python.org'))
helpMenu.addAction("About " + __doc__,
lambda: QMessageBox.about(self, __doc__, HELP))
helpMenu.addSeparator()
helpMenu.addAction(
"Keyboard Shortcut",
lambda: QMessageBox.information(self, __doc__, "<b>Quit = CTRL+Q"))
if sys.platform.startswith('linux'):
helpMenu.addAction("View Source Code", lambda:
call('xdg-open ' + __file__, shell=True))
helpMenu.addAction("View GitHub Repo", lambda: open_new_tab(__url__))
helpMenu.addAction("Check Updates", lambda: Downloader(self))
# process
self.process = QProcess()
self.process.readyReadStandardOutput.connect(self._read_output)
self.process.readyReadStandardError.connect(self._read_errors)
self.process.finished.connect(self._process_finished)
self.process.error.connect(self._process_failed)
# widgets
self.group0, self.group1 = QGroupBox("Options"), QGroupBox("Paths")
self.group4, self.group5 = QGroupBox("Details"), QGroupBox("Miscs")
g0grid, g1vlay = QGridLayout(self.group0), QGridLayout(self.group1)
g5vlay, g4vlay = QVBoxLayout(self.group5), QVBoxLayout(self.group4)
# group 0 the options
self.module = QCheckBox("Create compiled extension module")
self.standalone = QCheckBox("Standalone executable binary output")
self.nofreeze = QCheckBox("No freeze all modules of standard library")
self.python_debug = QCheckBox("Use Python Debug")
self.warning = QCheckBox("Warnings for implicit exceptions at compile")
self.recurse_std = QCheckBox("Recursive compile the standard library")
self.recurse_not = QCheckBox("Force No recursive compiling")
self.execute = QCheckBox("Execute the created binary after compiling")
self.pythonpath = QCheckBox("Keep pythonpath when executing")
self.enhaced = QCheckBox("Enhaced compile, Not CPython compatible")
self.nolineno = QCheckBox("No Statements line numbers on compile")
self.rmbuilddir = QCheckBox("Remove build directory after compile.")
self.nuitka_debug = QCheckBox("Use Nuitka Debug")
self.keep_debug = QCheckBox("Keep debug info on compile for GDB")
self.traced = QCheckBox("Traced execution output")
self.plusplus = QCheckBox("Compile C++ Only on generated source files")
self.experimental = QCheckBox("Experimental features")
self.force_clang = QCheckBox("Force use of CLang")
self.force_mingw = QCheckBox("Force use of MinGW on MS Windows")
self.force_lto = QCheckBox("Use link time optimizations LTO")
self.show_scons = QCheckBox("Show Scons executed commands")
self.show_progress = QCheckBox("Show progress info and statistics")
self.show_summary = QCheckBox("Show final summary of included modules")
self.disable_console = QCheckBox("Disable the Console on MS Windows")
for i, widget in enumerate((
self.module, self.standalone, self.nofreeze, self.python_debug,
self.warning, self.recurse_std, self.recurse_not, self.execute,
self.pythonpath, self.enhaced, self.nolineno, self.rmbuilddir,
self.nuitka_debug, self.keep_debug, self.traced, self.plusplus,
self.experimental, self.force_clang, self.force_mingw,
self.force_lto, self.show_scons, self.show_progress,
self.show_summary, self.disable_console)):
widget.setToolTip(widget.text())
g0grid.addWidget(widget, i if i < i + 1 else i - (i - 1), i % 2)
# group 1 paths
self.target = QLineEdit()
self.outdir = QLineEdit(os.path.expanduser("~"))
self.t_icon = QLineEdit()
self.target.setToolTip("Python App file you want to Compile to Binary")
self.outdir.setToolTip("Folder to write Compiled Output Binary files")
self.t_icon.setToolTip("Icon image file to embed for your Python App")
self.target.setPlaceholderText("/full/path/to/target/python_app.py")
self.outdir.setPlaceholderText("/full/path/to/output/folder/")
self.t_icon.setPlaceholderText("/full/path/to/python_app/icon.png")
self.completer, self.dirs = QCompleter(self), QDirModel(self)
self.completer.setModel(self.dirs)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setCompletionMode(QCompleter.PopupCompletion)
self.completer.popup().setStyleSheet("border: 1px solid gray")
self.completer.popup().setVerticalScrollBarPolicy(
Qt.ScrollBarAlwaysOff)
self.outdir.setCompleter(self.completer)
self.t_icon.setCompleter(self.completer)
self.target.setCompleter(self.completer)
self.clear_1 = QPushButton(QIcon.fromTheme("edit-clear"), "", self,
clicked=lambda: self.target.clear())
self.clear_2 = QPushButton(QIcon.fromTheme("edit-clear"), "", self,
clicked=lambda: self.t_icon.clear())
self.clear_3 = QPushButton(QIcon.fromTheme("edit-clear"), "", self,
clicked=lambda: self.outdir.clear())
self.open_1 = QPushButton(
QIcon.fromTheme("folder-open"), "", self, clicked=lambda:
self.target.setText(str(QFileDialog.getOpenFileName(
self, __doc__, os.path.expanduser("~"), """Python (*.py);;
Python for Windows (*.pyw);;All (*.*)""")[0])))
self.open_2 = QPushButton(
QIcon.fromTheme("folder-open"), "", self, clicked=lambda:
self.t_icon.setText(str(QFileDialog.getOpenFileName(
self, __doc__, os.path.expanduser("~"),
"PNG (*.png);;JPG (*.jpg);;ICO (*.ico);;All (*.*)")[0])))
self.open_3 = QPushButton(
QIcon.fromTheme("folder-open"), "", self, clicked=lambda:
self.outdir.setText(str(QFileDialog.getExistingDirectory(
self, __doc__, os.path.expanduser("~")))))
self.l_icon = QLabel("Target Icon")
g1vlay.addWidget(QLabel("<b>Target Python"), 0, 0)
g1vlay.addWidget(self.target, 0, 1)
g1vlay.addWidget(self.clear_1, 0, 2)
g1vlay.addWidget(self.open_1, 0, 3)
g1vlay.addWidget(self.l_icon, 1, 0)
g1vlay.addWidget(self.t_icon, 1, 1)
g1vlay.addWidget(self.clear_2, 1, 2)
g1vlay.addWidget(self.open_2, 1, 3)
g1vlay.addWidget(QLabel("<b>Output Folder"), 2, 0)
g1vlay.addWidget(self.outdir, 2, 1)
g1vlay.addWidget(self.clear_3, 2, 2)
g1vlay.addWidget(self.open_3, 2, 3)
# group 4 the dome view mode
self.jobs = QSpinBox()
self.jobs.setRange(1, cpu_count())
self.jobs.setValue(cpu_count())
self.jobs.setToolTip("Backend Worker Jobs Processes")
self.python_version = QComboBox()
self.python_version.addItems(["2.7", "3.2", "3.3", "3.4"])
self.python_version.setToolTip("Python version to use with Nuitka")
self.display_tree = QPushButton("Display Tree")
self.display_tree.clicked.connect(
lambda: call(NUITKA + " --display-tree {}".format(
self.target.text()), shell=True))
self.dump_tree = QPushButton(
"View Docs", clicked=lambda:
open_new_tab("http://nuitka.net/doc/user-manual.html"))
self.open_log = QPushButton("View Logs")
_log = os.path.join(gettempdir(), "nuitka-gui.log")
_open = "xdg-open " if sys.platform.startswith("lin") else "open "
self.open_log.clicked.connect(lambda: call(_open + _log, shell=True))
self.open_folder = QPushButton("Open Build Folder")
self.open_folder.clicked.connect(lambda: call(
_open + str(self.outdir.text()).strip(), shell=True))
# self.display_tree.clicked.connect(self._display_tree)
g4vlay.addWidget(QLabel("<b>Worker Jobs"))
g4vlay.addWidget(self.jobs)
g4vlay.addWidget(QLabel("<b>Python Version"))
g4vlay.addWidget(self.python_version)
g4vlay.addWidget(QLabel("<b>Actions"))
g4vlay.addWidget(self.display_tree)
g4vlay.addWidget(self.dump_tree)
g4vlay.addWidget(self.open_log)
g4vlay.addWidget(self.open_folder)
# group 5 miscelaneous stuff
self.debug, self.scr = QCheckBox("Use Debug"), QCheckBox("Make Script")
self.chrt, self.ionice = QCheckBox("Slow CPU"), QCheckBox("Slow HDD")
self.minimi = QCheckBox("Auto Minimize")
self.chrt.setToolTip("Use Low CPU speed priority (Linux only)")
self.ionice.setToolTip("Use Low HDD speed priority (Linux only)")
self.scr.setToolTip("Generate a Bash Script to Compile with Nuitka")
self.debug.setToolTip("Use Debug Verbose mode")
self.minimi.setToolTip("Automatically Minimize when compiling starts")
self.scr.setChecked(True)
self.chrt.setChecked(True)
self.ionice.setChecked(True)
self.minimi.setChecked(True)
g5vlay.addWidget(self.debug)
g5vlay.addWidget(self.scr)
g5vlay.addWidget(self.chrt)
g5vlay.addWidget(self.ionice)
g5vlay.addWidget(self.minimi)
# option to show or hide some widgets on the gui
self.guimode = QComboBox()
self.guimode.addItems(('Full UX / UI', 'Simple UX / UI'))
self.guimode.setCurrentIndex(1)
self._set_guimode()
self.guimode.setStyleSheet("""QComboBox{background:transparent;
margin-left:25px;color:gray;text-decoration:underline;border:0}""")
self.guimode.currentIndexChanged.connect(self._set_guimode)
# buttons from bottom to close or proceed
self.bt = QDialogButtonBox(self)
self.bt.setStandardButtons(
QDialogButtonBox.Ok | QDialogButtonBox.Close)
self.bt.rejected.connect(self.close)
self.bt.accepted.connect(self.run)
if not sys.platform.startswith('lin'):
self.scr.setChecked(False)
self.chrt.setChecked(False)
self.ionice.setChecked(False)
self.scr.hide()
self.chrt.hide()
self.ionice.hide()
if not sys.platform.startswith('win'):
self.l_icon.hide()
self.t_icon.hide()
self.clear_2.hide()
self.open_2.hide()
if sys.platform.startswith('win'):
self.display_tree.hide()
# container for all groups of widgets
container = QWidget()
container_layout = QGridLayout(container) # Y, X
container_layout.addWidget(self.guimode, 0, 1)
container_layout.addWidget(self.group0, 1, 1)
container_layout.addWidget(self.group1, 2, 1)
container_layout.addWidget(self.group4, 1, 2)
container_layout.addWidget(self.group5, 2, 2)
container_layout.addWidget(self.bt, 3, 1)
self.setCentralWidget(container)
def check_paths(self):
"""Check that the paths are valid."""
if not os.path.isfile(self.target.text()):
log.error("Target File not found or not valid.")
QMessageBox.warning(self, __doc__.title(),
"Target File not found or not valid.")
return False
if not str(self.target.text()).endswith((".py", ".pyw")):
log.error("Target File not valid.")
QMessageBox.warning(self, __doc__.title(),
"Target File not valid.")
return False
if not os.path.isdir(self.outdir.text()):
log.error("Target Folder not found or not valid.")
QMessageBox.warning(self, __doc__.title(),
"Target Folder not found or not valid.")
return False
if self.t_icon.text() and not os.path.isfile(self.t_icon.text()):
log.warning("Target Icon File not found or not valid.")
QMessageBox.warning(self, __doc__.title(),
"Target Icon File not found or not valid.")
return True
else:
return True
def generate_build_command(self):
"""Generate a build command."""
return re.sub(r"\s+", " ", " ".join((
'chrt --verbose --idle 0' if self.chrt.isChecked() else '',
'ionice --ignore --class 3' if self.ionice.isChecked() else '',
NUITKA,
'--debug --verbose' if self.debug.isChecked() else '',
'--show-progress' if self.show_progress.isChecked() else '',
'--show-scons --show-modules' if self.show_scons.isChecked() else '',
'--unstriped' if self.keep_debug.isChecked() else '',
'--trace-execution' if self.traced.isChecked() else '',
'--remove-output' if self.rmbuilddir.isChecked() else '',
'--code-gen-no-statement-lines' if self.nolineno.isChecked() else '',
'--execute' if self.execute.isChecked() else '',
'--recurse-none' if self.recurse_not.isChecked() else '--recurse-all',
'--recurse-stdlib' if self.recurse_std.isChecked() else '',
'--clang' if self.force_clang.isChecked() else '',
'--lto' if self.force_lto.isChecked() else '',
'--c++-only' if self.plusplus.isChecked() else '',
'--windows-disable-console' if self.disable_console.isChecked() else '',
'--experimental' if self.experimental.isChecked() else '',
'--python-debug' if self.python_debug.isChecked() else '',
'--module' if self.module.isChecked() else '--standalone',
'--nofreeze-stdlib' if self.nofreeze.isChecked() else '',
'--mingw' if self.force_mingw.isChecked() else '',
'--warn-implicit-exceptions' if self.warning.isChecked() else '',
'--execute-with-pythonpath' if self.pythonpath.isChecked() else '',
'--enhanced' if self.enhaced.isChecked() else '',
'--icon="{}"'.format(self.t_icon.text()) if self.t_icon.text() else '',
'--python-version={}'.format(self.python_version.currentText()),
'--jobs={}'.format(self.jobs.value()),
'--output-dir="{}"'.format(self.outdir.text()),
'"{}"'.format(self.target.text()))))
def run(self):
"""Run the main method and run Nuitka."""
self.statusBar().showMessage('Working...')
log.debug("Working...")
if not self.check_paths():
return
command_to_run_nuitka = self.generate_build_command()
log.debug(command_to_run_nuitka)
self.process.start(command_to_run_nuitka)
if not self.process.waitForStarted():
log.error(self._read_errors())
return # ERROR
if self.scr.isChecked() and sys.platform.startswith("lin"):
script_file = str(self.target.text()).replace(".py",
"-nuitka-compile.sh")
log.debug("Writing Script {}".format(script_file))
with open(script_file, "w", encoding="utf-8") as script:
script.write("#!/usr/bin/env bash\n" + command_to_run_nuitka)
os.chmod(script_file, 0o755)
self.statusBar().showMessage(__doc__.title())
def _process_finished(self):
"""Finished sucessfuly."""
log.debug("Finished.")
self.showNormal()
def _read_output(self):
"""Read and return output."""
return str(self.process.readAllStandardOutput()).strip()
def _read_errors(self):
"""Read and return errors."""
log.debug(self.process.readAllStandardError())
return str(self.process.readAllStandardError()).strip()
def _process_failed(self):
"""Read and return errors."""
self.showNormal()
self.statusBar().showMessage(" ERROR: Failed ! ")
log.warning(str(self.process.readAllStandardError()).strip().lower())
return str(self.process.readAllStandardError()).strip().lower()
def _set_guimode(self):
"""Switch between simple and full UX."""
for widget in (self.group0, self.group4,
self.group5, self.statusBar(), self.menuBar()):
widget.hide() if self.guimode.currentIndex() else widget.show()
self.resize(self.minimumSize()
if self.guimode.currentIndex() else self.maximumSize())
self.center()
def skin(self, filename=None):
"""Open QSS from filename,if no QSS return None,if no filename ask."""
if not filename:
filename = str(QFileDialog.getOpenFileName(
self, __doc__ + "-Open QSS Skin file", os.path.expanduser("~"),
"CSS Cascading Style Sheet for Qt 5 (*.qss);;All (*.*)")[0])
if filename and os.path.isfile(filename):
log.debug(filename)
with open(filename, 'r') as file_to_read:
text = file_to_read.read().strip()
if text:
log.debug(text)
return text
def center(self):
"""Center the Window on the Current Screen,with Multi-Monitor support.
>>> MainWindow().center()
True
"""
window_geometry = self.frameGeometry()
mousepointer_position = QApplication.desktop().cursor().pos()
screen = QApplication.desktop().screenNumber(mousepointer_position)
centerPoint = QApplication.desktop().screenGeometry(screen).center()
window_geometry.moveCenter(centerPoint)
return bool(not self.move(window_geometry.topLeft()))
def move_to_mouse_position(self):
"""Center the Window on the Current Mouse position.
>>> MainWindow().move_to_mouse_position()
True
"""
window_geometry = self.frameGeometry()
window_geometry.moveCenter(QApplication.desktop().cursor().pos())
return bool(not self.move(window_geometry.topLeft()))
def closeEvent(self, event):
"""Ask to Quit."""
the_conditional_is_true = QMessageBox.question(
self, __doc__.title(), 'Quit ?.', QMessageBox.Yes | QMessageBox.No,
QMessageBox.No) == QMessageBox.Yes
event.accept() if the_conditional_is_true else event.ignore()
class PreferencesDialogBase(QDialog):
def __init__(self, parent, app, **kwargs):
flags = Qt.CustomizeWindowHint | Qt.WindowTitleHint | Qt.WindowSystemMenuHint
super().__init__(parent, flags, **kwargs)
self.app = app
all_languages = get_langnames()
self.supportedLanguages = sorted(SUPPORTED_LANGUAGES,
key=lambda lang: all_languages[lang])
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 _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 self.supportedLanguages:
self.languageComboBox.addItem(get_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("Options"))
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)
self.layout().setSizeConstraint(QLayout.SetFixedSize)
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 = self.supportedLanguages.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 = self.supportedLanguages[self.languageComboBox.currentIndex()]
oldlang = self.app.prefs.language
if oldlang not in self.supportedLanguages:
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)
def resetToDefaults(self):
self.load(Preferences())
#--- Events
def buttonClicked(self, button):
role = self.buttonBox.buttonRole(button)
if role == QDialogButtonBox.ResetRole:
self.resetToDefaults()
class MainWindow(QDialog):
def __init__(self):
super().__init__()
self.title = "Main window"
self.top = 55
self.left = 7
w = data.scale[0]
h = data.scale[1]
data.reso[0] = App.primaryScreen().size().width()
data.reso[1] = App.primaryScreen().size().height()
self.width = App.primaryScreen().size().width() / w
self.height = App.primaryScreen().size().height() / h
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
data.graphResolution = [
self.width / data.scale[2], self.height / data.scale[3]
]
self.setWindowIcon(QtGui.QIcon('icon1.ico'))
self.formLayout0 = QFormLayout()
self.groupBox0 = QGroupBox("Available Asks")
self.groupBox0.setLayout(self.formLayout0)
scroll0 = QScrollArea()
scroll0.setWidget(self.groupBox0)
scroll0.setWidgetResizable(True)
self.formLayout = QFormLayout()
self.groupBox = QGroupBox("Available Bids")
customTheme()
data.pref_prd = list(client.get_stars(data.username,
data.password)) # TODO UNCOMMENT
#print(client.get_stars(data.username, data.password))
self.groupBox.setLayout(self.formLayout)
scroll = QScrollArea()
scroll.setWidget(self.groupBox)
scroll.setWidgetResizable(True)
self.formLayout3 = QFormLayout()
self.groupBox3 = QGroupBox("Your orders")
self.groupBox3.setLayout(self.formLayout3)
scroll3 = QScrollArea()
scroll3.setWidget(self.groupBox3)
scroll3.setWidgetResizable(True)
self.formLayout1 = QFormLayout()
self.groupBox1 = QGroupBox("Orders' History")
history = client.get_history(data.username, data.password)
print("HERE WE GO AGAIN")
for r in history:
#print(r)
if len(r):
Order = QtWidgets.QPushButton()
if r[-1] == "sell":
sign = func.sellOrder(
r[0], r[1], r[2],
r[3]) # ordertype, product, amount, price
Order.setStyleSheet(styles.sellbutton)
else:
sign = func.buyOrder(r[0], r[1], r[2], r[3])
Order.setStyleSheet(styles.buybutton)
Order.setText(sign)
Order.setDisabled(True)
# formLayout1.addWidget(Order)
self.formLayout1.insertRow(0, Order)
self.groupBox1.setLayout(self.formLayout1)
scroll2 = QScrollArea()
scroll2.setWidget(self.groupBox1)
scroll2.setWidgetResizable(True)
rightArea = QVBoxLayout()
threeScrolls = QHBoxLayout()
threeScrolls.addWidget(scroll)
threeScrolls.addWidget(scroll0)
Column = QVBoxLayout()
Column.addWidget(scroll3)
Column.addWidget(scroll2)
threeScrolls.addLayout(Column)
rightArea.addLayout(threeScrolls)
leftArea = QVBoxLayout()
BuySell = QHBoxLayout()
buyButton = QtWidgets.QPushButton("BUY")
buyButton.setStyleSheet(
styles.buybuttonFus.replace("text-align: left;", ""))
BuySell.addWidget(buyButton)
sellButton = QtWidgets.QPushButton("SELL")
sellButton.setStyleSheet(
styles.sellbuttonFus.replace("text-align: left;", ""))
BuySell.addWidget(sellButton)
settingsButton = QtWidgets.QPushButton("configuring".upper())
BuySell.addWidget(settingsButton)
self.MainProduct = QComboBox()
self.MainProduct.currentIndexChanged.connect(
self.prdChanged, self.MainProduct.currentIndex())
self.MainProduct.addItem("No filter")
for prd in data.pref_prd:
self.MainProduct.addItem(prd)
BuySell.addWidget(self.MainProduct)
buy_shortcut = QShortcut(QtGui.QKeySequence("B"), self)
buy_shortcut.activated.connect(lambda: callOrderWindow("Buy"))
sell_shortcut = QShortcut(QtGui.QKeySequence("S"), self)
sell_shortcut.activated.connect(lambda: callOrderWindow("Sell"))
conf_shortcut = QShortcut(QtGui.QKeySequence("C"), self)
conf_shortcut.activated.connect(lambda: callConfigWindow())
my_assets = QShortcut(QtGui.QKeySequence("A"), self)
my_assets.activated.connect(lambda: call_my_assets())
buyButton.clicked.connect(lambda: callOrderWindow("Buy"))
sellButton.clicked.connect(lambda: callOrderWindow("Sell"))
settingsButton.clicked.connect(lambda: callConfigWindow())
shortcut1 = QShortcut(QtGui.QKeySequence("1"), self)
shortcut1.activated.connect(lambda: change_prd_keyboard(1))
shortcut2 = QShortcut(QtGui.QKeySequence("2"), self)
shortcut2.activated.connect(lambda: change_prd_keyboard(2))
shortcut3 = QShortcut(QtGui.QKeySequence("3"), self)
shortcut3.activated.connect(lambda: change_prd_keyboard(3))
shortcut4 = QShortcut(QtGui.QKeySequence("4"), self)
shortcut4.activated.connect(lambda: change_prd_keyboard(4))
shortcut5 = QShortcut(QtGui.QKeySequence("5"), self)
shortcut5.activated.connect(lambda: change_prd_keyboard(5))
shortcut6 = QShortcut(QtGui.QKeySequence("6"), self)
shortcut6.activated.connect(lambda: change_prd_keyboard(6))
shortcut7 = QShortcut(QtGui.QKeySequence("7"), self)
shortcut7.activated.connect(lambda: change_prd_keyboard(7))
shortcut8 = QShortcut(QtGui.QKeySequence("8"), self)
shortcut8.activated.connect(lambda: change_prd_keyboard(8))
shortcut9 = QShortcut(QtGui.QKeySequence("9"), self)
shortcut9.activated.connect(lambda: change_prd_keyboard(9))
shortcut0 = QShortcut(QtGui.QKeySequence("0"), self)
shortcut0.activated.connect(lambda: change_prd_keyboard(0))
shortcutR = QShortcut(QtGui.QKeySequence("F5"), self)
shortcutR.activated.connect(lambda: self.F5_EVENT())
leftArea.addLayout(BuySell)
graphsArea = QVBoxLayout()
self.graph1 = CanvasUp()
self.graph2 = CanvasLow()
self.sliderUP = QSlider(Qt.Horizontal)
self.sliderUP.setTickInterval(10)
self.sliderUP.setSingleStep(30)
self.sliderUP.valueChanged.connect(lambda: self.sliderChanged1())
self.sliderDOWN = QSlider(Qt.Horizontal)
self.sliderDOWN.setTickInterval(10)
self.sliderDOWN.setSingleStep(30)
self.sliderDOWN.valueChanged.connect(lambda: self.sliderChanged2())
self.load = QtWidgets.QLabel()
self.load1 = QtWidgets.QLabel()
self.tabs = QTabWidget()
self.graphUP = QWidget()
self.graphUP.layout = QVBoxLayout(self.graphUP)
self.graphUP.layout.addWidget(self.graph1)
self.graphUP.layout.addWidget(self.sliderUP)
self.tabs.setFixedHeight(data.graphResolution[0])
self.tabs.setFixedWidth(data.graphResolution[1])
self.tabs.addTab(self.graphUP, "Graph1")
graphsArea.addWidget(self.tabs)
self.tabs1 = QTabWidget()
self.graphLOW = QWidget()
self.graphLOW.layout = QVBoxLayout(self.graphLOW)
self.graphLOW.layout.addWidget(self.graph2)
self.graphLOW.layout.addWidget(self.sliderDOWN)
self.tabs1.setFixedHeight(data.graphResolution[0])
self.tabs1.setFixedWidth(data.graphResolution[1])
self.tabs1.addTab(self.graphLOW, "Graph2")
graphsArea.addWidget(self.tabs1)
leftArea.addLayout(graphsArea)
global bar
bar = QPushButton(func.barInfo())
bar.setStyleSheet(styles.barstyle1)
bar.clicked.connect(lambda: call_my_assets())
lowBar = QPushButton("NEWS: " +
data.news[randrange(0, len(data.news))])
lowBar.setStyleSheet(styles.news)
lowBar.setDisabled(True)
Mainlayout = QVBoxLayout(self)
ContentArea = QHBoxLayout()
ContentArea.addLayout(leftArea)
ContentArea.addLayout(rightArea)
Mainlayout.addWidget(bar)
Mainlayout.addLayout(ContentArea)
Mainlayout.addWidget(lowBar)
self.show()
self.thread = MyThread() #time
self.thread.timeToSleep = 0.3
self.thread.change_value.connect(lambda: setProgressVal())
self.thread.start()
self.thread1 = MyThread() # add possible orders
self.thread1.timeToSleep = 2.5
self.thread1.change_value.connect(lambda: self.getUpdate())
self.thread1.start()
self.thread2 = MyThread() # update graphs
self.thread2.timeToSleep = 4
self.thread2.change_value.connect(lambda: self.updateGraphs())
self.thread2.start()
self.thread3 = MyThread() # update news
self.thread3.timeToSleep = 7
self.thread3.change_value.connect(lambda: printNews())
self.thread3.start()
def setProgressVal():
bar.setText(func.barInfo())
def change_prd_keyboard(i):
try:
if i == 0:
self.MainProduct.setCurrentIndex(0)
elif len(data.pref_prd) > i - 1:
self.MainProduct.setCurrentIndex(i)
else:
self.MainProduct.setCurrentIndex(0)
except:
print("error in change_prd_keyboard")
def callConfigWindow():
data.orderResolution[0], data.orderResolution[
1] = self.width / 2.3, self.height / 1.7
Dialog = QtWidgets.QDialog()
ui = cfg.Ui_DialogConfig()
ui.setupUi(Dialog)
Dialog.exec_()
if data.mode == "Dark":
switchDark()
bar.setStyleSheet(styles.barstyle2)
else:
QtWidgets.QApplication.instance().setPalette(
self.style().standardPalette())
switchLight()
bar.setStyleSheet(styles.barstyle1)
if data.clearHis == True:
try:
for i in reversed(range(self.formLayout1.count())):
self.formLayout1.itemAt(i).widget().deleteLater()
except:
pass
data.clearHis = False
if data.addToBox[0]:
self.MainProduct.clear()
self.MainProduct.addItem("No filter")
for prd in data.pref_prd:
self.MainProduct.addItem(prd)
data.addToBox = [False, []]
if data.joinG[0] == True and data.joinG[1] == True:
self.updateGraphs()
self.graph1.upd()
self.graph2.upd()
if self.MainProduct.currentText() == "No filter":
self.graph1.clear()
self.graph1.no_data()
self.graph2.clear()
self.graph2.no_data()
if data.joinG[0] == True and data.joinG[1] == True:
data.zoom1 = data.zoom
tm = time.time()
step = 3600
tm_ = tm - 60 * 60 * 24
inp = [[x, x + step]
for x in range(int(tm_), int(tm), int(step))]
prd = self.MainProduct.currentText()
data.bx = client.box_graph(prd, inp)
#data.bx1 = client.box_graph(prd, inp)
data.bx_lab = inp
#print("Box", inp)
data.box_reload = 0
def call_my_assets():
data.orderResolution[0], data.orderResolution[
1] = self.width / data.scale_[0], self.height / data.scale_[1]
Dialog = QtWidgets.QDialog()
ui = assets.Ui_DialogAssets()
ui.setupUi(Dialog)
Dialog.exec_()
def callOrderWindow(type):
data.orderWinIsON = True
data.orderResolution[0], data.orderResolution[
1] = self.width / data.scale_[2], self.height / data.scale_[3]
data.orderType = str(type)
if self.MainProduct.currentText() != "No filter":
try:
amtN = 0 # для средневзвешенного
wcc = 0
# computing autocomplete prices
if str(type) == "Buy":
for i in reversed(range(self.formLayout0.count())):
try:
#print("=>",func.getPrice(self.formLayout0.itemAt(i).widget().text()))
amtN += float(
func.getAmt(
self.formLayout0.itemAt(
i).widget().text()))
wcc += float(
func.getAmt(
self.formLayout0.itemAt(
i).widget().text())) * float(
func.getPrice(
self.formLayout0.itemAt(
i).widget().text()))
except:
pass
data.acPrice = func.getPrice(
self.formLayout0.itemAt(0).widget().text())
#print("wcc1",wcc, amtN)
data.acPriceFOK = (wcc / (amtN))
else:
for i in reversed(range(self.formLayout.count())):
try:
amtN += float(
func.getAmt(
self.formLayout.itemAt(
i).widget().text()))
wcc += float(
func.getAmt(
self.formLayout.itemAt(
i).widget().text())) * float(
func.getPrice(
self.formLayout.itemAt(
i).widget().text()))
except:
pass
#print("wcc2", wcc, amtN)
data.acPrice = func.getPrice(
self.formLayout.itemAt(self.formLayout.count() -
1).widget().text())
data.acPriceFOK = wcc / (amtN)
except:
pass
data.autocomplete = self.MainProduct.currentText()
Dialog = QtWidgets.QDialog()
ui = ord.Ui_DialogOrder()
ui.setupUi(Dialog)
Dialog.exec_()
if data.addToHis[0]: ### ALSO CHECKS FOR SUCCESS
sign = func.Order(data.addToHis[1][0], data.addToHis[1][1],
data.addToHis[1][2], data.addToHis[1][3],
data.addToHis[1][4])
newOrder = QtWidgets.QPushButton()
newOrder.setStyleSheet(styles.buybutton)
if data.addToHis[1][0].lower() == "sell":
newOrder.setStyleSheet(styles.sellbutton)
newOrder.setDisabled(True)
newOrder.setText(sign)
self.formLayout1.insertRow(0, newOrder)
bar.setText(func.barInfo()) #CHEANGE BALANCE
#RELOADING AVALIABLE ORDERS
self.reloadData()
elif data.addToOrd[0]:
self.reloadData()
if len(data.system_ord) != 0:
self.reloadSystemOrders("")
data.addToHis = (False, [])
data.addToOrd = (False, "Buy", "")
data.acPrice = ""
bal = client.get_balance(data.username)
data.balance = (bal, "$")
func.putPersonalData()
bar.setText(func.barInfo())
data.orderWinIsON = False
def printNews():
i = randrange(0, len(data.news))
lowBar.setText("NEWS: " + data.news[i])
def keyPressEvent(self, event):
if event.key() == QtCore.Qt.Key_B:
print("b pressed")
def sliderChanged1(self):
if self.MainProduct.currentText() != "No filter":
data.zoom = self.sliderUP.value()
self.graph1.clear()
self.graph1.reloading()
self.reloading()
if len(data.graphsData) == 0:
self.graph1.clear()
self.graph1.no_data()
def sliderChanged2(self):
if self.MainProduct.currentText() != "No filter":
data.zoom1 = self.sliderDOWN.value()
self.graph2.clear()
self.graph2.reloading()
self.reloading()
if len(data.graphsData_1) == 0:
self.graph2.clear()
self.graph2.no_data()
def F5_EVENT(self):
data.box_reload = 0
self.reloading()
self.updateGraphs()
def reloading(self):
print("__reloading__")
try:
if data.joinG[0] == True and data.joinG[1] == True:
data.zoom1 = data.zoom
tm = time.time()
step = 3600
tm_ = tm - 60 * 60 * 24
inp = [[x, x + step]
for x in range(int(tm_), int(tm), int(step))]
prd = self.MainProduct.currentText()
data.bx = client.box_graph(prd, inp)
# data.bx1 = client.box_graph(prd, inp)
data.bx_lab = inp
# print("Box", inp)
data.sleep += 1
if data.sleep == 60:
data.sleep = 0
if data.zoom != 0:
data.graphsData = client.stats(
self.MainProduct.currentText(),
time.time() - (1100 - data.zoom * 10),
time.time() + 15, "buy")
else:
data.graphsData = client.stats(self.MainProduct.currentText(),
0,
time.time() + 15, "buy")
if data.zoom1 != 0:
data.graphsData_1 = client.stats(
self.MainProduct.currentText(),
time.time() - (1100 - data.zoom1 * 10),
time.time() + 15, "sell")
else:
data.graphsData_1 = client.stats(
self.MainProduct.currentText(), 0,
time.time() + 15, "sell")
except:
print("Error in reloading")
def updateGraphs(self):
print("TIME: ", time.time() - data.working_time)
try:
if self.MainProduct.currentText() != "No filter":
self.graph1.clear()
if data.joinG[0] == True and data.joinG[1] == True:
self.sliderUP.setHidden(True)
self.graph1.plot_joint()
else:
self.sliderUP.setHidden(False)
self.reloading()
self.graph1.plot()
if data.joinG[0] == True and data.joinG[1] == True:
if data.box_reload < 1:
self.sliderDOWN.setHidden(True)
self.graph2.clear()
self.graph2.candels()
data.box_reload += 1
else:
self.graph2.clear()
self.graph2.plot()
self.sliderDOWN.setHidden(False)
else:
data.graphsData = []
data.graphsData_1 = []
except:
print("Error in update graphs")
def prdChanged(self):
data.chosen_prd = self.MainProduct.currentText()
data.box_reload = 0
self.sliderChanged1()
self.sliderChanged2()
if self.MainProduct.currentText() == "No filter":
if not data.FIRSTSTART:
self.graph1.clear()
self.graph1.no_data()
self.graph2.clear()
self.graph2.no_data()
data.FIRSTSTART = False
self.reloadData()
def reloadData(self):
if data.joinG[0] == True and data.joinG[1] == True:
data.sleep = 0
try:
text = self.MainProduct.currentText()
data.prd = text
res1 = []
res2 = []
if text == "No filter":
try:
if data.goLocal:
raise Exception
except:
print(
"EXCEPTION OCCURRED: Local database is used instead ")
else:
try:
if data.goLocal:
raise Exception
res1 = client.exe(
"SELECT * FROM orders WHERE product='{}' AND request='{}'ORDER BY price LIMIT 20"
.format(text, "sell"))
res2 = client.exe(
"SELECT * FROM orders WHERE product='{}' AND request='{}'ORDER BY price LIMIT 20"
.format(text, "buy"))
except:
print(
"EXCEPTION OCCURRED: Local database is used instead ")
res = func.findOrder(text)
res = client.exe(
f"SELECT * FROM orders WHERE uid={float(data.userid)}")
data.yourOrd = data.system_ord
data.system_ord = []
try:
for i in reversed(range(self.formLayout.count())):
self.formLayout.itemAt(i).widget().deleteLater()
except:
pass
j2 = 0
for order in res:
j2 += 1
if order[3] == "sell":
if order[-1] == float(data.userid):
sys_ord = [
order[2], order[3], order[4],
str(order[5]),
str(order[6]),
str(order[0])
]
if sys_ord not in data.system_ord:
data.system_ord.append(sys_ord)
data.ORDDIC[order[0]] = order
else:
if order not in data.Orders:
data.ORDDIC[order[0]] = order
try:
for i in reversed(range(self.formLayout0.count())):
self.formLayout0.itemAt(i).widget().deleteLater()
except:
pass
j3 = 0
for order in res:
j3 += 1
if order[3] == "buy":
if order[-1] == float(data.userid):
sys_ord = [
order[2], order[3], order[4],
str(order[5]),
str(order[6]),
str(order[0])
]
if sys_ord not in data.system_ord:
data.system_ord.append(sys_ord)
data.ORDDIC[order[0]] = order
else:
if order not in data.Orders:
data.ORDDIC[order[0]] = order
# add to history
try:
for el in data.yourOrd:
if el not in data.system_ord and not data.orderWinIsON:
msg = QMessageBox()
msg.setWindowTitle("An order's been executed")
msg.setIconPixmap(QPixmap("arrow.png").scaled(80, 80))
msg_text = "This order\n"
thisorder = QPushButton()
if el[1] == "buy":
thisorder.setStyleSheet(styles.buybutton)
thisorder.setText(
func.buyOrder("Limit", el[2], el[3], el[4]))
data.balance = (data.balance[0] -
float(el[3]) * float(el[4]),
data.balance[1])
#msg_text += func.buyOrder("Limit", el[2], el[3], el[4])
msg_text += "Limit Buy" + el[2]
else:
thisorder.setStyleSheet(styles.sellbutton)
thisorder.setText(
func.sellOrder("Limit", el[2], el[3], el[4]))
data.balance = (data.balance[0] +
float(el[3]) * float(el[4]),
data.balance[1])
#msg_text += func.sellOrder("Limit", el[2], el[3], el[4])
msg_text += "Limit Sell" + el[2]
thisorder.setDisabled(True)
self.formLayout1.insertRow(0, thisorder)
msg.setText(msg_text + "\nhas been executed.")
msg.setWindowIcon(QtGui.QIcon('bgicon.ico'))
msg.exec_()
except:
print("line 676")
res = res1 + res2
if self.MainProduct.currentText() != "No filter":
prices = func.merger(res)
for el in prices:
if prices[el][1][3] == "sell":
thisorder = QPushButton()
thisorder.setStyleSheet(styles.sellbutton)
sign = func.sellOrder(prices[el][1][2],
prices[el][1][4],
str(prices[el][0]),
prices[el][1][6])
thisorder.setText(sign)
self.formLayout0.addRow(thisorder)
else:
thisorder = QPushButton()
thisorder.setStyleSheet(styles.buybutton)
sign = func.buyOrder(prices[el][1][2],
prices[el][1][4],
str(prices[el][0]),
prices[el][1][6])
thisorder.setText(sign)
self.formLayout.insertRow(0, thisorder)
self.reloadSystemOrders("")
except:
print("Error in def reloadData")
if data.error == False:
data.error = True
connect()
def removeOrder(self, n):
oldstyle = self.formLayout3.itemAt(n - 1).widget().styleSheet()
self.formLayout3.itemAt(n - 1).widget().setStyleSheet(styles.buttonY)
data.orderResolution[0], data.orderResolution[
1] = self.width / 2.5, self.height / 1.3
Dialog = QtWidgets.QDialog()
ui = confirmwin.Ui_DialogCONFIRM()
ui.setupUi(Dialog)
Dialog.exec_()
try:
if data.toDelete:
client.delete(data.username, data.system_ord[n - 1][-1])
for i in reversed(range(self.formLayout3.count())):
self.formLayout3.itemAt(i).widget().deleteLater()
del data.system_ord[n - 1]
self.reloadSystemOrders("")
bal = client.get_balance(data.username)
data.balance = (bal, "$")
func.putPersonalData()
bar.setText(func.barInfo())
else:
self.formLayout3.itemAt(n - 1).widget().setStyleSheet(oldstyle)
data.toDelete = False
except:
print("Error in remove order")
def reloadSystemOrders(self, temp):
try:
for i in reversed(range(self.formLayout3.count())):
self.formLayout3.itemAt(i).widget().deleteLater()
j1 = 0
for el in data.system_ord:
j1 += 1
thisorder = QPushButton(
"", clicked=lambda _, n=j1: self.removeOrder(n))
if el[1] == "buy":
thisorder.setStyleSheet(styles.buybutton)
thisorder.setText(
func.buyOrder("Limit", el[2], el[3],
el[4] + "\n id: " + el[-1]))
else:
thisorder.setStyleSheet(styles.sellbutton)
thisorder.setText(
func.sellOrder("Limit", el[2], el[3],
el[4] + "\n id: " + el[-1]))
self.formLayout3.insertRow(0, thisorder)
except:
print("Error reloadSystemOrders")
def getUpdate(self):
self.reloadData()
def closeEvent(self, event):
print("Goodbye")
# TODO приложение работает в фоновом режиме даже после закрытия
self.thread.terminate()
self.thread1.terminate()
self.thread2.terminate()
self.thread3.terminate()
pid = os.getpid()
os.kill(pid, signal.SIGINT)
print(pid)
print("BYE")
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()
class Window(QMainWindow):
def __init__(self, width, height, initState):
super().__init__()
self.title = "MineSweeper"
self.top = 200
self.left = 200
self.height = height
self.width = width
self.sq = 50
self.currX = 0
self.currY = 0
self.steps = 0
self.prevX = self.currX
self.prevY = self.currY
self.startTime = time.time()
self.endTime = time.time()
self.iconName = "minesweeper.png"
self.drawType = 1
self.initState = initState
# self.visitedBoard = [[0 for i in range(self.initState.col)] for j in range(self.initState.row)]
self.InitWindow()
def InitWindow(self):
self.setWindowIcon(QIcon(self.iconName))
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.UiComponents()
self.show()
def UiComponents(self):
initTop = 45
initLeft = 990
btnWidth = 300
btnHeight = 50
marginTop = 30
self.topLabel = QLabel("MineSweeper Simulation : ", self)
self.topLabel.setFont(QFont("Sanserif", 12))
self.topLabel.setGeometry(10, 5, initLeft, 20)
self.btmLabel = QLabel("Status Bar : ", self)
self.btmLabel.setFont(QFont("Sanserif", 10))
self.btmLabel.setGeometry(10, initTop + (11 * 60) + marginTop,
initLeft, 20)
self.buttons = []
for i in range(4):
self.buttons.append(QPushButton("", self))
self.buttons[i].setGeometry(
QRect(initLeft, initTop + (i * (btnHeight + marginTop)),
btnWidth, btnHeight))
self.buttons[i].setIconSize(QSize(50, 50))
self.buttons[0].setText("Start Game")
self.buttons[0].setIcon(QIcon("start.png"))
self.buttons[0].clicked.connect(self.startBtnClick)
self.buttons[1].setText("Next Step")
self.buttons[1].setIcon(QIcon("next.png"))
self.buttons[1].clicked.connect(self.nextBtnClick)
self.buttons[1].setDisabled(True)
self.buttons[2].setText("Stop")
self.buttons[2].setIcon(QIcon("stop.png"))
self.buttons[2].clicked.connect(self.stopBtnClick)
self.buttons[2].setDisabled(True)
self.buttons[3].setText("Analysis Module")
self.buttons[3].setIcon(QIcon("ana.png"))
self.buttons[3].clicked.connect(self.openAnalysisWindows)
self.groupBox = QGroupBox("Select Algorithm : ", self)
vbox = QGridLayout(self)
self.rad1 = QRadioButton("Hill Climbing")
self.rad1.setChecked(True)
vbox.addWidget(self.rad1, 0, 0)
self.comboBox = QComboBox(self)
self.comboBox.addItem("Stochastic")
self.comboBox.addItem("Random Restart")
self.comboBox.addItem("Local Beam Search")
vbox.addWidget(self.comboBox, 0, 1)
self.rad2 = QRadioButton("Simulated Annealing")
vbox.addWidget(self.rad2, 1, 0)
self.comboBox2 = QComboBox(self)
self.comboBox2.addItem("With Threshold")
self.comboBox2.addItem("Without Threshold")
vbox.addWidget(self.comboBox2, 1, 1)
self.groupBox.setLayout(vbox)
self.groupBox.setFont(QFont("Sanserif", 10))
self.groupBox.setGeometry(initLeft - 60,
initTop + (6 * btnHeight) + marginTop,
btnWidth + 100, 200)
label2 = QLabel("Choose number of mines: ", self)
label2.setFont(QFont("Sanserif", 10))
label2.setGeometry(initLeft - 60,
initTop + (6 * btnHeight) + 230 + marginTop, 250,
30)
self.comboBox3 = QComboBox(self)
self.comboBox3.setFont(QFont("Sanserif", 10))
self.comboBox3.setGeometry(initLeft - 60 + 270,
initTop + (6 * btnHeight) + 230 + marginTop,
80, 30)
for i in range(30):
self.comboBox3.addItem(str(i + 1), i + 1)
self.comboBox3.setCurrentIndex(14)
label3 = QLabel("Choose Heuristic: ", self)
label3.setFont(QFont("Sanserif", 10))
label3.setGeometry(initLeft - 60,
initTop + (6 * btnHeight) + 300 + marginTop, 250,
30)
self.comboBox4 = QComboBox(self)
self.comboBox4.setFont(QFont("Sanserif", 10))
self.comboBox4.setGeometry(initLeft - 60 + 270,
initTop + (6 * btnHeight) + 300 + marginTop,
120, 30)
self.comboBox4.addItem("Heuristic 1")
self.comboBox4.addItem("Heuristic 2")
self.drawType = 1
self.update()
def startBtnClick(self):
self.drawType = 2
self.initState.visited = [[0 for i in range(self.initState.col)]
for j in range(self.initState.row)]
self.initState.board = [[0 for i in range(self.initState.col)]
for j in range(self.initState.row)]
self.initState.htable1 = [[100 for i in range(self.initState.col)]
for j in range(self.initState.row)]
self.mines = int(str(self.comboBox3.currentText()))
self.initState.left = self.initState.row * self.initState.col
self.initState.mineGenerator(self.mines)
self.buttons[0].setDisabled(True)
self.buttons[2].setEnabled(True)
self.buttons[1].setEnabled(True)
self.steps = 0
self.steps += 1
self.startTime = time.time()
self.endTime = time.time()
self.currX, self.currY = self.initState.firstClick()
# get which algo we are using for sim and update top bar
self.heur = self.comboBox4.currentIndex()
# print(self.heur)
if self.rad1.isChecked():
self.algo = (1, self.comboBox.currentIndex())
self.topLabel.setText("MineSweeper Simulation : Hill Climbing" +
" " + self.comboBox.currentText() + " " +
self.comboBox4.currentText())
else:
self.algo = (2, self.comboBox2.currentIndex())
self.topLabel.setText(
"MineSweeper Simulation : Simulated Annealing " +
self.comboBox2.currentText() + " " +
self.comboBox4.currentText())
print(self.algo)
self.btmLabel.setText("Status Bar: ")
self.initState.nextState(self.currX, self.currY)
# self.initState.printVisited()
self.update()
# time.sleep(0.5)
self.checkMine()
def createMessageBox(self, text):
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText(text)
msg.setWindowTitle("Minesweeper")
msg.setStandardButtons(QMessageBox.Ok)
msg.setModal(True)
retval = msg.exec()
return retval
def checkMine(self):
# s = "Choose grid no: {},{}".format(self.currX, self.currY)
# self.btmLabel.setText(s)
self.drawType = 2
s = self.btmLabel.text()
if self.initState.board[self.currX][self.currY] == 9:
print("Game over")
self.drawType = 3
self.buttons[0].setEnabled(True)
self.buttons[2].setDisabled(True)
self.buttons[1].setDisabled(True)
self.topLabel.setText("MineSweeper Simulation : Game Over !!")
self.btmLabel.setText(s + " You hit a mine")
self.createMessageBox("Game over")
self.endTime = time.time()
self.drawType = 1
self.update()
def stopBtnClick(self):
self.initState.visited = [[0 for i in range(self.initState.col)]
for j in range(self.initState.row)]
self.buttons[2].setDisabled(True)
self.buttons[0].setEnabled(True)
self.buttons[1].setDisabled(True)
self.topLabel.setText("MineSweeper Simulation : ")
self.btmLabel.setText("Status Bar: ")
self.drawType = 3
self.update()
self.createMessageBox("You stopped the game.")
self.drawType = 1
self.update()
self.endTime = time.time()
#
def nextBtnClick(self):
self.steps += 1
self.prevX = self.currX
self.prevY = self.currY
if self.heur == 0:
self.initState.heuristic1()
else:
self.initState.heuristic1()
if self.algo[0] == 1 and self.algo[1] == 0:
h, self.currX, self.currY = self.initState.stochasticHillClimbing()
if self.algo[0] == 1 and self.algo[1] == 1:
h, self.currX, self.currY = self.initState.randomRestartHillClimbing(
self.prevX, self.prevY, self.currX, self.currY)
if self.algo[0] == 1 and self.algo[1] == 2:
h, self.currX, self.currY = self.initState.kbeamHillClimbing(
self.currX, self.currY)
if self.algo[0] == 2 and self.algo[1] == 0:
h, self.currX, self.currY = self.initState.SimAnThreshold(
self.currX, self.currY)
if self.algo[0] == 2 and self.algo[1] == 1:
h, self.currX, self.currY = self.initState.SimAn(
self.currX, self.currY)
s = "Choose grid no: {},{} Heuristic Value: {}".format(
self.currX, self.currY, h)
self.btmLabel.setText(s)
self.drawType = 2
self.initState.nextState(self.currX, self.currY)
self.checkMine()
print("left {} mines {}".format(self.initState.left, self.mines))
if self.initState.left == self.mines:
self.createMessageBox("You Won!!")
self.endTime = time.time()
def openAnalysisWindows(self):
self.dialog = QDialog()
self.dialog.setWindowTitle("Analysis Module")
self.dialog.setGeometry(self.top + 50, self.left + 50, 600, 400)
self.dialog.setModal(True)
self.dialog.setWindowIcon(QIcon("ana.png"))
self.InitAnalysisDialog()
self.dialog.exec()
def InitAnalysisDialog(self):
initTop = 50
initLeft = 50
btnWidth = 200
btnHeight = 90
topLabel = QLabel("Analysis Module : ", self.dialog)
topLabel.setFont(QFont("Sanserif", 14))
topLabel.setGeometry(40, 40, 400, 50)
self.hillClimbingBtn = QPushButton("Hill Climbing", self.dialog)
self.hillClimbingBtn.setGeometry(
QRect(initLeft, initTop + 100, btnWidth, btnHeight))
self.hillClimbingBtn.clicked.connect(self.openHillClimbingAna)
self.simAnBtn = QPushButton("Simulated Annealing", self.dialog)
self.simAnBtn.setGeometry(
QRect(initLeft + btnWidth + 40, initTop + 100, btnWidth,
btnHeight))
self.simAnBtn.clicked.connect(self.openSimAnAna)
def openHillClimbingAna(self):
self.dialog2 = QDialog()
self.dialog2.setWindowTitle("Hill Climbing Analysis Module")
self.dialog2.setGeometry(self.top + 50, self.left + 50, self.width,
self.height)
self.dialog2.setModal(True)
self.dialog2.setWindowIcon(QIcon("ana.png"))
self.InitAnalysisDialogHC()
self.dialog2.exec()
def InitAnalysisDialogHC(self):
initTop = 45
initLeft = 45
btnWidth = 400
btnHeight = 60
marginTop = 80
labelWidth = 600
labelHeight = 50
topLabel = QLabel("Analysis : ", self.dialog2)
topLabel.setFont(QFont("Sanserif", 16))
topLabel.setGeometry(10, 5, initLeft, 60)
label1 = QLabel("R1) Memory : ", self.dialog2)
label1.setFont(QFont("Sanserif", 12))
label1.setGeometry(10, 5 + marginTop, labelWidth, labelHeight)
label1 = QLabel("", self.dialog2)
# self.initState.row*self.initState.col*3 : for 3 2d arrays
# 4: x,y pointers for current and prev
# 4: sizeof int
mem = self.initState.row*self.initState.col*3 \
+4 \
* 4
label1.setFont(QFont("Sanserif", 12))
label1.setGeometry(10 + labelWidth + 30, 5 + marginTop, labelWidth,
labelHeight)
label1.setText(str(mem))
label2 = QLabel("R2) Time : ", self.dialog2)
label2.setFont(QFont("Sanserif", 12))
label2.setGeometry(10, 5 + marginTop + labelHeight, labelWidth,
labelHeight)
label2 = QLabel("", self.dialog2)
label2.setText(str(self.endTime - self.startTime))
label2.setFont(QFont("Sanserif", 12))
label2.setGeometry(10 + labelWidth + 30, 5 + marginTop + labelHeight,
labelWidth, labelHeight)
label3 = QLabel("R3) Local Optimal Solution : ", self.dialog2)
label3.setFont(QFont("Sanserif", 12))
label3.setGeometry(10, 5 + marginTop + labelHeight * 2, labelWidth,
labelHeight)
label3 = QLabel("", self.dialog2)
s = "Last Local Optimal Solution X: {} Y: {}".format(
self.prevX, self.prevY)
label3.setFont(QFont("Sanserif", 12))
label3.setGeometry(10 + labelWidth + 30,
5 + marginTop + labelHeight * 2, labelWidth,
labelHeight)
label3.setText(s)
label4 = QLabel("R4) Behaviour of Stochastic Hill Climbing with H1 : ",
self.dialog2)
label4.setFont(QFont("Sanserif", 12))
label4.setGeometry(10, 5 + marginTop + labelHeight * 3, labelWidth,
labelHeight)
label4 = QLabel(
"Precomputed Value: For {}X{} grid - {} mines: 23 steps".format(
self.initState.row, self.initState.col, 15), self.dialog2)
label4.setFont(QFont("Sanserif", 12))
label4.setGeometry(10 + labelWidth + 30,
5 + marginTop + labelHeight * 3, labelWidth,
labelHeight)
label5 = QLabel("R5) Behaviour of Stochastic Hill Climbing with H2 : ",
self.dialog2)
label5.setFont(QFont("Sanserif", 12))
label5.setGeometry(10, 5 + marginTop + labelHeight * 4, labelWidth,
labelHeight)
label5 = QLabel("Not implemented", self.dialog2)
label5.setFont(QFont("Sanserif", 12))
label5.setGeometry(10 + labelWidth + 30,
5 + marginTop + labelHeight * 4, labelWidth,
labelHeight)
label6 = QLabel("R6) Number of steps : ", self.dialog2)
label6.setFont(QFont("Sanserif", 12))
label6.setGeometry(10, 5 + marginTop + labelHeight * 5, labelWidth,
labelHeight)
label6 = QLabel(str(self.steps), self.dialog2)
label6.setFont(QFont("Sanserif", 12))
label6.setGeometry(10 + labelWidth + 30,
5 + marginTop + labelHeight * 5, labelWidth,
labelHeight)
label7 = QLabel(
"R7) Behaviour of Random Restart Hill Climbing with H1 : ",
self.dialog2)
label7.setFont(QFont("Sanserif", 12))
label7.setGeometry(10, 5 + marginTop + labelHeight * 6, labelWidth,
labelHeight)
label7 = QLabel(
"Precomputed Value: For {}X{} grid - {} mines: 31 steps".format(
self.initState.row, self.initState.col, 15), self.dialog2)
label7.setFont(QFont("Sanserif", 12))
label7.setGeometry(10 + labelWidth + 30,
5 + marginTop + labelHeight * 6, labelWidth,
labelHeight)
label8 = QLabel(
"R8) Behaviour of Random Restart Hill Climbing with H2 : ",
self.dialog2)
label8.setFont(QFont("Sanserif", 12))
label8.setGeometry(10, 5 + marginTop + labelHeight * 7, labelWidth,
labelHeight)
label8 = QLabel("Not Implemented ", self.dialog2)
label8.setFont(QFont("Sanserif", 12))
label8.setGeometry(10 + labelWidth + 30,
5 + marginTop + labelHeight * 7, labelWidth,
labelHeight)
label9 = QLabel("R9) Behaviour of local beam search with H1 : ",
self.dialog2)
label9.setFont(QFont("Sanserif", 12))
label9.setGeometry(10, 5 + marginTop + labelHeight * 8, labelWidth,
labelHeight)
label9 = QLabel(
"Precomputed Value: For {}X{} grid - {} mines: 29 steps".format(
self.initState.row, self.initState.col, 15), self.dialog2)
label9.setFont(QFont("Sanserif", 12))
label9.setGeometry(10 + labelWidth + 30,
5 + marginTop + labelHeight * 8, labelWidth,
labelHeight)
label10 = QLabel("R10) Behaviour of local beam search with H2 : ",
self.dialog2)
label10.setFont(QFont("Sanserif", 12))
label10.setGeometry(10, 5 + marginTop + labelHeight * 9, labelWidth,
labelHeight)
label10 = QLabel("Not Implemented ", self.dialog2)
label10.setFont(QFont("Sanserif", 12))
label10.setGeometry(10 + labelWidth + 30,
5 + marginTop + labelHeight * 9, labelWidth,
labelHeight)
self.g2Btn = QPushButton("G2. Landscape", self.dialog2)
self.g2Btn.setGeometry(QRect(initLeft, 650, btnWidth, btnHeight))
self.g2Btn.clicked.connect(self.showG2)
self.g4Btn = QPushButton("G4. Effect of size of war field",
self.dialog2)
self.g4Btn.setGeometry(
QRect(initLeft + btnWidth + marginTop, 650, btnWidth, btnHeight))
self.g4Btn.clicked.connect(self.showG4)
def showG2(self):
data = []
for i in range(self.initState.row):
for j in range(self.initState.col):
data.append(self.initState.htable1[i][j])
ex = Graph('Landscape at current time ', data)
def showG4(self):
data = [
5, 12, 18, 29, 37, 48
] #average number of steps taken if varying field size with constant mine size
ex = Graph(
'Precomputed Value: Effect of field size with constant mine size',
data)
pass
def openSimAnAna(self):
self.dialog3 = QDialog()
self.dialog3.setWindowTitle("Simulated Annealing Analysis Module")
self.dialog3.setGeometry(self.top + 50, self.left + 50, self.width,
self.height)
self.dialog3.setModal(True)
self.dialog3.setWindowIcon(QIcon("ana.png"))
self.InitAnalysisDialogSA()
self.dialog3.exec()
def InitAnalysisDialogSA(self):
initTop = 45
initLeft = 800
btnWidth = 400
btnHeight = 60
marginTop = 80
labelWidth = 500
labelHeight = 50
topLabel = QLabel("Analysis : ", self.dialog3)
topLabel.setFont(QFont("Sanserif", 16))
topLabel.setGeometry(10, 5, initLeft, 60)
label1 = QLabel("R11) Memory : ", self.dialog3)
label1.setFont(QFont("Sanserif", 12))
label1.setGeometry(10, 5 + marginTop, labelWidth, labelHeight)
# self.initState.row*self.initState.col*3 : for 3 2d arrays
# 4: x,y pointers for current and prev
# 4: sizeof int
mem = self.initState.row * self.initState.col * 3 \
+ 4 \
* 4
label1 = QLabel(str(mem), self.dialog3)
label1.setFont(QFont("Sanserif", 12))
label1.setGeometry(10 + labelWidth + 30, 5 + marginTop, labelWidth,
labelHeight)
label2 = QLabel("R12) Time : ", self.dialog3)
label2.setFont(QFont("Sanserif", 12))
label2.setGeometry(10, 5 + marginTop + labelHeight, labelWidth,
labelHeight)
label2 = QLabel(" ", self.dialog3)
label2.setText(str(self.endTime - self.startTime))
label2.setFont(QFont("Sanserif", 12))
label2.setGeometry(10 + labelWidth + 30, 5 + marginTop + labelHeight,
labelWidth, labelHeight)
label3 = QLabel("R13) Local Optimal Solution : ", self.dialog3)
label3.setFont(QFont("Sanserif", 12))
label3.setGeometry(10, 5 + marginTop + labelHeight * 2, labelWidth,
labelHeight)
s = "Last Local Optimal Solution X: {} Y: {}".format(
self.prevX, self.prevY)
label3 = QLabel(s, self.dialog3)
label3.setFont(QFont("Sanserif", 12))
label3.setGeometry(10 + labelWidth + 30,
5 + marginTop + labelHeight * 2, labelWidth,
labelHeight)
label4 = QLabel("R14) Behaviour of Simulated Annealing with H1 : ",
self.dialog3)
label4.setFont(QFont("Sanserif", 12))
label4.setGeometry(10, 5 + marginTop + labelHeight * 3, labelWidth,
labelHeight)
label4 = QLabel("R1. Memory : ", self.dialog3)
label4.setFont(QFont("Sanserif", 12))
label4.setGeometry(10 + labelWidth + 30,
5 + marginTop + labelHeight * 3, labelWidth,
labelHeight)
label5 = QLabel("R15) Behaviour of Simulated Annealing with H2 : ",
self.dialog3)
label5.setFont(QFont("Sanserif", 12))
label5.setGeometry(10, 5 + marginTop + labelHeight * 4, labelWidth,
labelHeight)
label5 = QLabel("Not implemented", self.dialog3)
label5.setFont(QFont("Sanserif", 12))
label5.setGeometry(10 + labelWidth + 30,
5 + marginTop + labelHeight * 4, labelWidth,
labelHeight)
self.g6Btn = QPushButton("G6. Landscape", self.dialog3)
self.g6Btn.setGeometry(
QRect(initLeft, initTop + 100, btnWidth, btnHeight))
self.g6Btn.clicked.connect(self.showG6)
self.g7Btn = QPushButton("G7. Temperature range", self.dialog3)
self.g7Btn.setGeometry(
QRect(initLeft, initTop + 150 + btnHeight, btnWidth, btnHeight))
self.g7Btn.clicked.connect(self.showG7)
def showG6(self):
print("show graph")
pass
def showG7(self):
print("show graph")
pass
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
qp.setRenderHint(QPainter.Antialiasing)
if self.drawType == 1:
self.DrawInitGrid(qp)
if self.drawType == 2:
self.DrawGridRevealingSquares(qp)
if self.drawType == 3:
self.DrawGridRevealingMines(qp)
qp.end()
# print(e)
def DrawInitGrid(self, qp):
initTop = 55
initLeft = 40
qp.setPen(QPen(Qt.black, 1, Qt.SolidLine))
qp.setBrush(QBrush(Qt.gray, Qt.SolidPattern))
font = QFont()
font.setPointSize(16)
qp.setFont(font)
#
for i in range(self.initState.row):
for j in range(self.initState.col):
x = initLeft + (j * self.sq)
y = initTop + (i * self.sq)
# print("x: {} y: {}".format(x,y))
qp.drawRect(x, y, self.sq, self.sq)
def DrawGridRevealingMines(self, qp):
initTop = 55
initLeft = 40
qp.setPen(QPen(Qt.black, 1, Qt.SolidLine))
font = QFont()
font.setPointSize(16)
qp.setFont(font)
for i in range(self.initState.row):
for j in range(self.initState.col):
x = initLeft + (j * self.sq)
y = initTop + (i * self.sq)
if self.initState.board[i][j] == 9:
qp.setBrush(QBrush(QColor(255, 0, 0, 127),
Qt.SolidPattern))
qp.drawRect(x, y, self.sq, self.sq)
elif self.initState.board[i][j] == 0:
qp.setBrush(QBrush(QColor(0, 255, 0, 127),
Qt.SolidPattern))
qp.drawRect(x, y, self.sq, self.sq)
else:
qp.setBrush(QBrush(QColor(0, 255, 0, 127),
Qt.SolidPattern))
qp.drawRect(x, y, self.sq, self.sq)
qp.drawText(QPoint(x + 25, y + 35),
str(self.initState.board[i][j]))
def DrawGridRevealingSquares(self, qp):
initTop = 55
initLeft = 40
qp.setPen(QPen(Qt.black, 1, Qt.SolidLine))
font = QFont()
font.setPointSize(16)
qp.setFont(font)
for i in range(self.initState.row):
for j in range(self.initState.col):
x = initLeft + (j * self.sq)
y = initTop + (i * self.sq)
if self.initState.visited[i][j] == 1 and self.initState.board[
i][j] == 0:
qp.setBrush(QBrush(QColor(0, 255, 0, 127),
Qt.SolidPattern))
qp.drawRect(x, y, self.sq, self.sq)
elif self.initState.visited[i][j] == 1:
qp.setBrush(QBrush(QColor(0, 255, 0, 127),
Qt.SolidPattern))
qp.drawRect(x, y, self.sq, self.sq)
qp.drawText(QPoint(x + 25, y + 35),
str(self.initState.board[i][j]))
else:
qp.setBrush(QBrush(Qt.gray, Qt.SolidPattern))
qp.drawRect(x, y, self.sq, self.sq)
if i == self.currX and j == self.currY:
qp.setBrush(QBrush(QColor(30, 63, 161), Qt.SolidPattern))
qp.drawRect(x, y, self.sq, self.sq)
if self.initState.board[i][j] != 0:
qp.drawText(QPoint(x + 25, y + 35),
str(self.initState.board[i][j]))
class AddPayment(QDialog):
def __init__(self):
super().__init__()
#general variables
self.reciept_no = -1
self.roll = -1
self.fee = -1
self.semester = -1
self.date = -1
self.btnCancel = QPushButton("Cancelar", self)
self.btnReset = QPushButton("Resetear", self)
self.btnAdd = QPushButton("Agregar", self)
self.btnCancel.setFixedHeight(30)
self.btnReset.setFixedHeight(30)
self.btnAdd.setFixedHeight(30)
self.semesterCombo = QComboBox(self)
self.semesterCombo.addItem("Impar")
self.semesterCombo.addItem("Par")
self.rollLabel = QLabel("Nro de enrolamiento")
self.feeLabel = QLabel("Costo total")
self.semesterLabel = QLabel("Semestre")
self.rollText = QLineEdit(self)
self.feeLabelText = QLineEdit(self)
self.grid = QGridLayout(self)
self.grid.addWidget(self.rollLabel, 1, 1)
self.grid.addWidget(self.feeLabel, 2, 1)
self.grid.addWidget(self.semesterLabel, 3, 1)
self.grid.addWidget(self.rollText, 1, 2)
self.grid.addWidget(self.feeLabelText, 2, 2)
self.grid.addWidget(self.semesterCombo, 3, 2)
#adding three buttons
self.grid.addWidget(self.btnReset, 4, 1)
self.grid.addWidget(self.btnCancel, 4, 3)
self.grid.addWidget(self.btnAdd, 4, 2)
#button connectors
self.btnAdd.clicked.connect(self.addPayment)
self.btnCancel.clicked.connect(QApplication.instance().quit)
self.btnReset.clicked.connect(self.reset)
self.setLayout(self.grid)
self.setWindowTitle("Agregar pago")
self.setWindowIcon(QIcon('Logo.ico'))
self.setWindowFlags(Qt.WindowCloseButtonHint
| Qt.MSWindowsFixedSizeDialogHint)
self.resize(400, 200)
self.show()
sys.exit(self.exec())
def reset(self):
self.rollText.setText("")
self.feeLabelText.setText("")
def addPayment(self):
self.semester = self.semesterCombo.currentIndex()
self.roll = int(self.rollText.text())
self.fee = int(self.feeLabelText.text())
self.dbhelper = DBHelper()
self.dbhelper.addPayment(self.roll, self.fee, self.semester)
class AddStudent(QDialog):
def __init__(self):
super().__init__()
#general variables
self.gender = -1
self.branch = -1
self.year = -1
self.roll = -1
self.name = ""
self.address = ""
self.mobile = -1
self.academic_year = -1
self.btnCancel = QPushButton("Cancelar", self)
self.btnReset = QPushButton("Resetear", self)
self.btnAdd = QPushButton("Agregar", self)
self.btnCancel.setFixedHeight(30)
self.btnReset.setFixedHeight(30)
self.btnAdd.setFixedHeight(30)
self.yearCombo = QComboBox(self)
self.yearCombo.addItem("1ero")
self.yearCombo.addItem("2do")
self.yearCombo.addItem("3ero")
self.yearCombo.addItem("4to")
self.genderCombo = QComboBox(self)
self.genderCombo.addItem("Hombre")
self.genderCombo.addItem("Mujer")
self.branchCombo = QComboBox(self)
self.branchCombo.addItem("Ingeniería Civil")
self.branchCombo.addItem("Ingeniería Electronica")
self.branchCombo.addItem("Ingeniería Industrial")
self.branchCombo.addItem("Ingeniería Informatica")
self.branchCombo.addItem("Ingeniería Mecanica")
self.branchCombo.addItem("Ingeniería Quimica")
self.rollLabel = QLabel("Nro de enrolamiento")
self.nameLabel = QLabel("Nombre")
self.addressLabel = QLabel("Dirección")
self.mobLabel = QLabel("Celular")
self.yearLabel = QLabel("Año")
self.academicYearLabel = QLabel("Año academico")
self.branchLabel = QLabel("Carrera")
self.genderLabel = QLabel("Genero")
self.rollText = QLineEdit(self)
self.nameText = QLineEdit(self)
self.addressText = QLineEdit(self)
self.mobText = QLineEdit(self)
self.academicYearText = QLineEdit(self)
self.grid = QGridLayout(self)
self.grid.addWidget(self.rollLabel, 1, 1)
self.grid.addWidget(self.nameLabel, 2, 1)
self.grid.addWidget(self.genderLabel, 3, 1)
self.grid.addWidget(self.addressLabel, 4, 1)
self.grid.addWidget(self.mobLabel, 5, 1)
self.grid.addWidget(self.branchLabel, 6, 1)
self.grid.addWidget(self.yearLabel, 7, 1)
self.grid.addWidget(self.academicYearLabel, 8, 1)
self.grid.addWidget(self.rollText, 1, 2)
self.grid.addWidget(self.nameText, 2, 2)
self.grid.addWidget(self.genderCombo, 3, 2)
self.grid.addWidget(self.addressText, 4, 2)
self.grid.addWidget(self.mobText, 5, 2)
self.grid.addWidget(self.branchCombo, 6, 2)
self.grid.addWidget(self.yearCombo, 7, 2)
self.grid.addWidget(self.academicYearText, 8, 2)
#adding three buttons
self.grid.addWidget(self.btnReset, 9, 1)
self.grid.addWidget(self.btnCancel, 9, 3)
self.grid.addWidget(self.btnAdd, 9, 2)
#button connectors
self.btnAdd.clicked.connect(self.addStudent)
self.btnCancel.clicked.connect(QApplication.instance().quit)
self.btnReset.clicked.connect(self.reset)
self.setLayout(self.grid)
self.setWindowTitle("Agregar estudiante")
self.setWindowIcon(QIcon('Logo.ico'))
self.setWindowFlags(Qt.WindowCloseButtonHint
| Qt.MSWindowsFixedSizeDialogHint)
self.resize(500, 300)
self.show()
sys.exit(self.exec())
def reset(self):
self.rollText.setText("")
self.academicYearText.setText("")
self.nameText.setText("")
self.addressText.setText("")
self.mobText.setText("")
def addStudent(self):
self.gender = self.genderCombo.currentIndex()
self.year = self.yearCombo.currentIndex()
self.branch = self.branchCombo.currentIndex()
self.roll = int(self.rollText.text())
self.name = self.nameText.text()
self.academic_year = int(self.academicYearText.text())
self.address = self.addressText.text()
self.mobile = int(self.mobText.text())
self.dbhelper = DBHelper()
self.dbhelper.addStudent(self.roll, self.name, self.gender,
self.branch, self.year, self.academic_year,
self.address, self.mobile)
class Example(QWidget):
def __init__(self):
super().__init__()
self.ventana()
def ventana(self):
#Planteamiento de etiquetas
self.inp = QLineEdit("Numero de datos", self)
self.inp.move(5, 5)
self.x = QLineEdit(self)
self.x.move(5, 50)
self.y = QLineEdit(self)
self.y.move(160, 50)
lbl = QLabel("x", self)
lbl.move(5, 30)
lbl2 = QLabel("y", self)
lbl2.move(160, 30)
self.lbl3 = QLabel(self)
self.lbl3.move(5, 75)
self.inp2 = QLineEdit("Conocer X en", self)
self.inp2.move(5, 100)
self.lbl4 = QLabel("y=...", self)
self.lbl4.move(160, 100)
self.com = QComboBox(self)
self.com.move(160, 5)
but = QPushButton("Calcular", self)
but.move(5, 130)
#Eventos
self.com.activated[str].connect(self.onAc)
self.inp.textChanged[str].connect(self.combo)
self.x.textChanged[str].connect(self.lx)
self.y.textChanged[str].connect(self.ly)
self.inp.selectionChanged.connect(self.bor)
self.x.selectionChanged.connect(self.bor2)
self.y.selectionChanged.connect(self.bor3)
self.inp2.selectionChanged.connect(self.bor4)
but.clicked.connect(self.boton)
#Ventana
self.setGeometry(300, 300, 350, 160)
self.setWindowTitle('Regresion Lineal')
self.show()
#Metodos de los eventos
def boton(self):
sp = 0
ss = 0
ym = 0
xm = 0
b1 = 0
b0 = 0
te = int(self.inp.text())
for c in range(te):
ym += yl[c]
xm += xl[c]
c = 0
ym /= te
xm /= te
for c in range(te):
sp += (xl[c] - xm) * (yl[c] - ym)
ss += (xl[c] - xm)**2
b1 = sp / ss
b0 = ym - (b1 * xm)
if self.inp2.text() == '':
self.inp2.setText("0")
cp = float(self.inp2.text())
r = b0 + (b1 * cp)
self.lbl4.setText("y=" + str(r))
self.lbl4.adjustSize()
self.lbl3.setText("y=" + str(b0) + "+(" + str(b1) + "x)")
self.lbl3.adjustSize()
def bor(self):
self.inp.clear()
def bor2(self):
self.x.clear()
def bor3(self):
self.y.clear()
def bor4(self):
self.inp2.clear()
def combo(self, text):
self.com.clear()
if text == '':
text = '0'
for c in range(int(text)):
self.com.addItem(str(c + 1))
if len(xl) <= c:
xl.append(0)
yl.append(0)
def lx(self, text):
if text == "":
text = "0"
xl[(self.com.currentIndex())] = float(text)
def ly(self, text):
if text == "":
text = "0"
yl[(self.com.currentIndex())] = float(text)
def onAc(self, text):
if self.x.text() == " ":
xl[int(text) - 1] = 0
if self.y.text() == " ":
yl[int(text) - 1] = 0
self.x.setText(str(xl[int(text) - 1]))
self.y.setText(str(yl[int(text) - 1]))
class Custom_ToolBar(QToolBar):
send_fitsobj = pyqtSignal(object)
send_filename = pyqtSignal(str)
send_filenames = pyqtSignal(list)
send_message = pyqtSignal(str)
#Our personalized custom Toolbar
def __init__(self, mainWindow):
super().__init__()
#------- internal variables -------
self.mW = mainWindow
self.loadspec = None
self.fitsobj = mainWindow.fitsobj
self.fits_2daux = Fits_2dAux()
self.filepaths = []
self.filenames = []
self.filename = ''
self.display2d = None # displayed 2d spectrum
self.scale = 0
self.manual = None # No user manual yet
self.extract1d = None # wait for sent_extract1d
self.maxfile_lim = 50 # max displayed files in f_combobox at a time
self.setWindowTitle('Customizable TooBar')
#self.setFixedSize(QSize(200, 50))
# "Read All" button
btn_loadtxt = self._create_button(
'Read All',
'Read all fits files from a TXT file. Make sure you run "ls *.fits > filenames.txt" before clicking this!'
)
self.addAction(btn_loadtxt)
btn_loadtxt.triggered.connect(self._load_from_txt)
# "Read FITS" button
btn_loadf = self._create_button(
'Read FITS', 'Read a fits file and plot the spectrum')
self.addAction(btn_loadf)
btn_loadf.triggered.connect(self._load_specs)
# "Save Extract1D" button
btn_savef = self._create_button('Save Extract1D',
'Save the extracted 1D FITS file')
self.addAction(btn_savef)
btn_savef.triggered.connect(self._save_spec)
self.addSeparator()
# "PREV" buttons for file dropbox
btn_prevf = self._create_button(
'PREV', 'Swtich to previous fits file loaded in backend.')
self.addAction(btn_prevf)
btn_prevf.triggered.connect(self._prev_fitsfile)
# File dropbox
self.f_combobox = QComboBox()
self.f_combobox.setMinimumWidth(200)
self.f_combobox.addItem('No FITS File')
self.f_combobox.setCurrentIndex(0)
# set the max visible items for one page
self.f_combobox.setMaxVisibleItems(self.maxfile_lim)
self.f_combobox.currentIndexChanged.connect(self._read_selected_fits)
self.addWidget(self.f_combobox)
# "NEXT" buttons for file dropbox
btn_nextf = self._create_button(
'NEXT', 'Switch to next fits file loaded in backend.')
self.addAction(btn_nextf)
btn_nextf.triggered.connect(self._next_fitsfile)
self.addSeparator()
# Frame dropbox section
if self.mW.toggle_frames:
self.frames = None
# '-' button for frame dropbox
btn_prevframe = self._create_button(
'-', 'Swtich to previous available frame.')
self.addAction(btn_prevframe)
btn_prevframe.triggered.connect(self._prev_frame)
# main frame dropbox
self.frame_combobox = QComboBox()
self.frame_combobox.setMinimumWidth(130)
self.frame_combobox.addItem('NONE')
self.frame_combobox.setCurrentIndex(0)
self.frame_combobox.currentTextChanged.connect(self._select_frames)
self.addWidget(self.frame_combobox)
# '+' button for frame dropbox
btn_nextframe = self._create_button(
'+', 'Switch to next available frame.')
self.addAction(btn_nextframe)
btn_nextframe.triggered.connect(self._next_frame)
self.addSeparator()
# Scaling label
s_label = QLabel('Scale:')
self.addWidget(s_label)
# scaling dropbox
self.s_combobox = QComboBox()
self.s_combobox.setFixedWidth(100)
self.addWidget(self.s_combobox)
# normalization dropbox
self.n_combobox = QComboBox()
self.n_combobox.setFixedWidth(100)
self.addWidget(self.n_combobox)
# normalization range
self.min_range = QLineEdit()
self.min_range.setFixedWidth(100)
self.addWidget(self.min_range)
self.min_range.setPlaceholderText('Min')
self.min_range.returnPressed.connect(self._return_pressed)
self.min_range.setReadOnly(True)
self.max_range = QLineEdit()
self.max_range.setFixedWidth(100)
self.max_range.setPlaceholderText('Max')
self.max_range.returnPressed.connect(self._return_pressed)
self.max_range.setReadOnly(True)
self.addWidget(self.max_range)
self.addSeparator()
# "Advanced" Option
btn_adv = self._create_button('Advanced', 'More 2D inspection')
self.addAction(btn_adv)
btn_adv.triggered.connect(self._on_advanced_option)
self.addSeparator()
# "Help" button
btn_help = self._create_button(
'Help', 'Open the user manual for further help')
self.addAction(btn_help)
btn_help.triggered.connect(self._open_user_manual)
def _create_button(self, buttonName='', buttonTip=''):
#Create buttons wrapper
btn = QAction(buttonName, self.mW)
btn.setStatusTip(buttonTip)
return btn
def _open_user_manual(self, checked):
#Open User manual to help
if self.manual is None:
self.manual = UserManualDialog(method=1)
self.manual.show()
def _load_specs(self):
# This function corresponds to the action of "Read FITS" button
# Read multiple spec fits file
# only fetch filepath strings, do not open fits files here
if self.mW.xspecio:
filepaths, check = QFileDialog.getOpenFileNames(
None, 'Load multiple FITS/XSpec files', WORKING_DIR,
'Fits Files (*.fits);; XSpec Files (*.xspec)')
else:
filepaths, check = QFileDialog.getOpenFileNames(
None, 'Load multiple FITS files', WORKING_DIR,
'Fits Files (*.fits)')
if check:
filenames = [
self._get_filename(fp, extension=False) for fp in filepaths
]
if len(self.filepaths) > 0:
newfiles = [fi for fi in filenames if fi not in self.filenames]
self.filenames.extend(newfiles)
newpaths = [
fpi for fpi in filepaths if fpi not in self.filepaths
]
self.filepaths.extend(newpaths)
self.f_combobox.addItems(newfiles)
self.f_combobox.setCurrentIndex(
len(self.filenames) - len(newfiles) + 1)
#if len(self.filenames) > self.maxfile_lim:
# self.send_message.emit('Max displayed files are reached! Some files are folded in the dropdown box.')
else:
self.filenames = filenames
self.filepaths = filepaths
self.f_combobox.addItems(self.filenames)
self.f_combobox.setCurrentIndex(1)
def _load_from_txt(self):
# This function corresponds to the action of "Read All" button
# Read all fits files saved in a txt file
# the txt file should be located within the same folder as fits
txtpath, check = QFileDialog.getOpenFileName(
None,
'Read a TXT file containing all fits filenames in the current folder',
WORKING_DIR, 'Text Files (*.txt)')
if check:
with open(txtpath) as f:
lines = f.readlines()
txt_dirname = os.path.dirname(txtpath)
filepaths = [txt_dirname + '/' + line.strip() for line in lines]
filenames = [
self._get_filename(fp, extension=False) for fp in filepaths
]
if len(self.filepaths) > 0:
newfiles = [fi for fi in filenames if fi not in self.filenames]
self.filenames.extend(newfiles)
newpaths = [
fpi for fpi in filepaths if fpi not in self.filepaths
]
self.filepaths.extend(newpaths)
self.f_combobox.addItems(newfiles)
self.f_combobox.setCurrentIndex(
len(self.filenames) - len(newfiles) + 1)
#if len(self.filenames) > self.maxfile_lim:
# self.send_message.emit('Max displayed files are reached! Some files are folded in the dropdown box.')
else:
self.filenames = filenames
self.filepaths = filepaths
self.f_combobox.addItems(self.filenames)
self.f_combobox.setCurrentIndex(1)
def _save_spec(self):
# This function corresponds to the action of "Save Extract1D" button
# Save extract1d (wave, flux1d, error1d) with a deepcopy of loaded 2D spec
if self.loadspec is not None:
if self.extract1d is not None:
newfilename = self.filename + '_ymin={}_ymax={}'.format(
self.extract1d['YMIN'], self.extract1d['YMAX'])
filepath, check = QFileDialog.getSaveFileName(
None, 'Save 1D Spectrum FITS file', newfilename,
'Fits Files (*.fits)')
print(filepath)
if check:
# create a deepcopy first
hdul_copy = self.loadspec._save_copy()
# and then append a BinTable with WAVELENGTH, FLUX1D, ERROR1D
col1 = fits.Column(name='WAVELENGTH',
format='D',
array=self.extract1d['WAVELENGTH'])
col2 = fits.Column(name='FLUX',
format='D',
array=self.extract1d['FLUX'])
col3 = fits.Column(name='ERROR',
format='D',
array=self.extract1d['ERROR'])
cols = fits.ColDefs([col1, col2, col3])
tmp_hdu = fits.BinTableHDU.from_columns(cols)
tmp_hdu.name = 'EXTRACT1D'
hdul_copy.append(tmp_hdu)
hdr = hdul_copy[-1].header
# save ymin/ymax values in header as well
hdr.set('YMIN', self.extract1d['YMIN'],
'ymin value of the extracted box')
hdr.set('YMAX', self.extract1d['YMAX'],
'ymax value of the extracted box')
# ymin/ymax are written in the final filename
hdul_copy.writeto(filepath, overwrite=True)
print('Saving a fits file to [{}]'.format(filepath))
else:
self.send_message.emit('Please select a new extraction box.')
#self.extract1d = None # reset extraction object
else:
self.send_message.emit(
'Please read a FITS file first before saving!')
def _get_filename(self, filepath, extension=False):
# return the filename and ready to pass to other widgets
base = os.path.basename(filepath)
if extension:
return base
else:
return os.path.splitext(base)[0]
def _prev_fitsfile(self):
# This function corresponds to the action of "Prev" button
# Switch to the previous filename loaded in f_combobox
# idx 0 is "No FITS File" placeholder
idx_min = 1
current = self.f_combobox.currentIndex()
if current > idx_min:
self.f_combobox.setCurrentIndex(current - 1)
else:
pass
def _next_fitsfile(self):
# This function corresponds to the action of "Next" button
# Switch to the next filename loaded in f_combobox
current = self.f_combobox.currentIndex()
idx_max = self.f_combobox.count() - 1
if current < idx_max:
self.f_combobox.setCurrentIndex(current + 1)
else:
pass
def _on_advanced_option(self):
message = ''
if self.fits_2daux.stamp is not None:
img_sta = [self.fits_2daux.stamp]
if self.fits_2daux.wcs is not None:
img_sta.append(self.fits_2daux.wcs)
# Scaling/Normalization only control the last img
# make sure to swap positions for this one
img_sta[0], img_sta[1] = img_sta[1], img_sta[0]
self.img_sta = ShowAdvanced(img_sta, name='STAMP')
self.img_sta.show()
message += 'GUI found STAMP HDU.'
else:
message += 'GUI did not find STAMP HDU in the current fits file.'
if self.fits_2daux.zpdf is not None:
self.z_pdfplot = ZGuessPosterior(self.fits_2daux.zpdf)
self.z_pdfplot.show()
message += 'GUI found ZPosterior HDU.'
else:
message += 'GUI did not find ZPosterior HDU in the current fits file.'
imgs, names = [], []
if self.fitsobj.flux2d is not None:
imgs.append(self.fitsobj.flux2d)
names.append('FLUX')
else:
message += 'This fits file does not contain a 2D spectrum.'
#if self.fitsobj.error2d is not None:
# imgs.append(self.fitsobj.error2d)
# names.append('ERROR')
#else:
# message += 'This fits file does not contain a 2D error spectrum.'
if self.fits_2daux.source is not None:
imgs.append(self.fits_2daux.source)
names.append('SOURCE')
message += 'GUI found SRC HDU.'
else:
message += 'GUI did not find SRC HDU in the current fits file.'
if self.fits_2daux.continuum is not None:
imgs.append(self.fits_2daux.continuum)
names.append('CONTINUUM')
message += 'GUI found CONTINUUM HDU.'
else:
message += 'GUI did not find CONTINUUM HDU in the current fits file.'
if self.fits_2daux.contamination is not None:
imgs.append(self.fits_2daux.contamination)
names.append('CONTAMINATION')
message += 'GUI found CONTAMINATION HDU.'
else:
message += 'GUI did not find CONTAMINATION HDU in the current fits file.'
if len(imgs) > 0:
self.img_adv = ShowAdvanced(imgs, name=names)
self.img_adv.show()
else:
message += 'There is no additional images to inspect.'
self.send_message.emit(message)
# frame_combobox event
def _select_frames(self, s):
if self.fitsobj.flux2d is None:
# only 1d spec exists
pass
else:
# default is SCI
if (s == 'SCI') | (s == ''):
self.display2d = self.fitsobj.flux2d
else:
self.display2d = self.frames[s]
self.mW.sc.plot_spec2d(self.fitsobj.wave, self.display2d,
self.fitsobj.error2d, self.filename)
# reset scale and normalization comboboxes
self.s_combobox.setCurrentIndex(0)
self.n_combobox.setCurrentIndex(0)
if (s + '1d' in self.frames1d.keys()) and (self.frames1d[s + '1d']
is not None):
#print('replotting...')
self.mW.sc.replot(self.fitsobj.wave, self.frames1d[s + '1d'],
self.frames1d['ERR1d'])
self.send_message.emit('Optimal Extraction Found!')
def _prev_frame(self):
# This function corresponds to the action of "-" button
# Switch to the previous frame loaded in frame_combobox
idx_min = 0
current = self.frame_combobox.currentIndex()
if current > idx_min:
self.frame_combobox.setCurrentIndex(current - 1)
else:
self.frame_combobox.setCurrentIndex(self.frame_combobox.count() -
1)
def _next_frame(self):
# This function corresponds to the action of "-" button
# Switch to the next frame loaded in frame_combobox
current = self.frame_combobox.currentIndex()
idx_max = self.frame_combobox.count() - 1
if current < idx_max:
self.frame_combobox.setCurrentIndex(current + 1)
else:
# wrap around
self.frame_combobox.setCurrentIndex(0)
# combobox event
def _read_selected_fits(self, i):
# default is 0 ==> No fits file
# filepaths index = i - 1
if i < 1:
pass
else:
self.filename = self.filenames[i - 1]
print(f'Currently, GUI reads FITS file from {self.filepaths[i-1]}')
if self.mW.xspecio:
# enable XSpectrum1D io
#print('xspec io mode')
from gui_io_xspec import LoadXSpec
self.loadspec = LoadXSpec(self.filepaths[i - 1])
if len(self.loadspec.warning) > 0:
# even XSpectrum1D cant read this file
self.send_message.emit(self.loadspec.warning)
else:
self.fitsobj = self.loadspec._load_spec()
# XSpectrum1D only reads 1D fits file
self.mW.sc.plot_spec(self.fitsobj.wave, self.fitsobj.flux,
self.fitsobj.error, self.filename)
self.s_combobox.clear()
self.send_filename.emit(self.filename)
self.send_fitsobj.emit(self.fitsobj)
else:
# enable standalone IO class
#print('default io mode')
from gui_io import LoadSpec
fnlist = self.filepaths[i - 1].split('_')
# searching for corresponding 2D for advanced display
if '1D' in fnlist[-2]:
fits2d_path = '_'.join(fnlist[:-2] + ['2D'] + [fnlist[-1]])
if os.path.exists(fits2d_path):
self.filepaths[i - 1] = fits2d_path
self.filename = fits2d_path.split('/')[-1].split(
'.')[0]
self.loadspec = LoadSpec(self.filepaths[i - 1])
selfcheck = self.loadspec._load_spec()
#print(selfcheck)
if type(selfcheck) is str:
print('bad fits format')
self.send_message.emit(selfcheck)
else:
self.fitsobj = self.loadspec._load_spec()
if (self.fitsobj.flux2d
is not None) & (self.fitsobj.flux is None):
# only 2d spec exists
self.display2d = self.fitsobj.flux2d
self.mW.sc.plot_spec2d(self.fitsobj.wave,
self.display2d,
self.fitsobj.error2d,
self.filename)
self._add_scale2d()
elif (self.fitsobj.flux
is not None) & (self.fitsobj.flux2d is None):
# only 1d spec exists
self.mW.sc.plot_spec(self.fitsobj.wave,
self.fitsobj.flux,
self.fitsobj.error, self.filename)
self.s_combobox.clear()
self.n_combobox.clear()
self.min_range.clear()
self.min_range.setReadOnly(True)
self.max_range.clear()
self.max_range.setReadOnly(True)
elif (self.fitsobj.flux is not None) & (self.fitsobj.flux2d
is not None):
# both 1d and 2d specs exist
# check if filename has keywords ymin/ymax for 2D fits
if ('ymin' in self.filename) & ('ymax'
in self.filename):
flist = self.filename.split('.')[0].split('_')
extraction_box = [
int(flist[-2][5:]),
int(flist[-1][5:])
]
self.display2d = self.fitsobj.flux2d
self.mW.sc.plot_spec2d(
self.fitsobj.wave,
self.display2d,
self.fitsobj.error2d,
self.filename,
prev_extraction=extraction_box)
self.mW.sc.replot(self.fitsobj.wave,
self.fitsobj.flux,
self.fitsobj.error)
else:
# if not, set up extraction box as usual
self.display2d = self.fitsobj.flux2d
self.mW.sc.plot_spec2d(self.fitsobj.wave,
self.display2d,
self.fitsobj.error2d,
self.filename,
prev_extraction=None)
self.mW.sc.replot(self.fitsobj.wave,
self.fitsobj.flux,
self.fitsobj.error)
self._add_scale2d()
self.send_filename.emit(self.filename)
self.send_fitsobj.emit(self.fitsobj)
self.fits_2daux = self.loadspec._check_advanced()
# toggle_frames only available for default io
if self.mW.toggle_frames:
from gui_frame_io import ToggleFrames
toggle_f = ToggleFrames(self.filepaths[i - 1])
self.frames, self.frames1d = toggle_f._check_available_frames(
)
self.frame_combobox.clear()
for frame_name in self.frames.keys():
if self.frames[frame_name] is not None:
self.frame_combobox.addItem(str(frame_name))
# reset scale and normalization comboboxes
self.s_combobox.setCurrentIndex(0)
self.n_combobox.setCurrentIndex(0)
def _add_scale2d(self):
self.s_combobox.setMaxCount(4)
self.s_combobox.addItems(['Linear', 'Log', 'Sqrt', 'Square'])
self.s_combobox.setCurrentIndex(0)
self.s_combobox.currentIndexChanged.connect(self._scaling_changed)
self.n_combobox.setMaxCount(12)
self.n_combobox.addItems([
'None', 'MinMax', '99.5%', '99%', '98%', '97%', '96%', '95%',
'92.5%', '90%', 'Z-Score', 'Manual'
])
self.n_combobox.setCurrentIndex(0)
self.n_combobox.currentIndexChanged.connect(
self._normalization_changed)
self.min_range.setReadOnly(False)
self.max_range.setReadOnly(False)
def _scaling_changed(self, i):
if self.fitsobj.flux2d is not None:
self.mW.sc.plot_spec2d(self.fitsobj.wave,
self.display2d,
self.fitsobj.error2d,
self.filename,
scale=i)
self.scale = i
else:
pass
def _normalization_changed(self, i):
if self.fitsobj.flux2d is not None:
if i < 11:
self.mW.sc.plot_spec2d(self.fitsobj.wave,
self.display2d,
self.fitsobj.error2d,
self.filename,
scale=self.scale,
normalization=i)
else:
pass
def _on_scale_limits_slot(self, sent_limits):
self.min_range.setText(str(sent_limits[0]))
self.max_range.setText(str(sent_limits[1]))
def _return_pressed(self):
# min,max current values
manual_range = [
float(self.min_range.text()),
float(self.max_range.text())
]
# sort and assign min,max values to avoid user errors
manual_range.sort()
self.min_range.setText(str(manual_range[0]))
self.max_range.setText(str(manual_range[-1]))
self.n_combobox.setCurrentIndex(11)
self.mW.sc.plot_spec2d(self.fitsobj.wave,
self.display2d,
self.fitsobj.error2d,
self.filename,
scale=self.scale,
normalization=manual_range)
def _on_sent_extract1d(self, sent_extract1d):
self.extract1d = sent_extract1d
class Drums(_base.Part):
@staticmethod
def title(_=_base.translate):
return _("Drums")
@staticmethod
def short(_=_base.translate):
return _("abbreviation for Drums", "Dr.")
def createWidgets(self, layout):
self.voicesLabel = QLabel()
self.voices = QSpinBox(minimum=1, maximum=4, value=1)
self.drumStyleLabel = QLabel()
self.drumStyle = QComboBox()
self.drumStyle.setModel(listmodel.ListModel(drumStyles, self.drumStyle, display=listmodel.translate))
self.drumStems = QCheckBox()
box = QHBoxLayout()
box.addWidget(self.voicesLabel)
box.addWidget(self.voices)
layout.addLayout(box)
box = QHBoxLayout()
box.addWidget(self.drumStyleLabel)
box.addWidget(self.drumStyle)
layout.addLayout(box)
layout.addWidget(self.drumStems)
def translateWidgets(self):
self.voicesLabel.setText(_("Voices:"))
self.drumStyleLabel.setText(_("Style:"))
self.drumStems.setText(_("Remove stems"))
self.drumStems.setToolTip(_("Remove the stems from the drum notes."))
self.drumStyle.model().update()
def assignDrums(self, data, name = None):
r"""Creates an empty name = \drummode assignment.
Returns the assignment.
"""
a = data.assign(name)
s = ly.dom.DrumMode(a)
ly.dom.Identifier(data.globalName, s)
ly.dom.LineComment(_("Drums follow here."), s)
ly.dom.BlankLine(s)
return a
def build(self, data, builder):
p = ly.dom.DrumStaff()
s = ly.dom.Simr(p)
if self.voices.value() > 1:
for i in range(1, self.voices.value() + 1):
q = ly.dom.Seq(ly.dom.DrumVoice(parent=s))
ly.dom.Text('\\voice' + ly.util.int2text(i), q)
a = self.assignDrums(data, 'drum' + ly.util.int2text(i))
ly.dom.Identifier(a.name, q)
else:
a = self.assignDrums(data, 'drum')
ly.dom.Identifier(a.name, s)
builder.setInstrumentNamesFromPart(p, self, data)
i = self.drumStyle.currentIndex()
if i > 0:
v = ('drums', 'timbales', 'congas', 'bongos', 'percussion')[i]
p.getWith()['drumStyleTable'] = ly.dom.Scheme(v + '-style')
v = (5, 2, 2, 2, 1)[i]
ly.dom.Line("\\override StaffSymbol #'line-count = #{0}".format(v), p.getWith())
if self.drumStems.isChecked():
ly.dom.Line("\\override Stem #'stencil = ##f", p.getWith())
ly.dom.Line("\\override Stem #'length = #3 % " + _("keep some distance."),
p.getWith())
data.nodes.append(p)
class Palette_Docker(DockWidget):
# Init the docker
def __init__(self):
super().__init__()
# make base-widget and layout
widget = QWidget()
layout = QVBoxLayout()
buttonLayout = QHBoxLayout()
widget.setLayout(layout)
self.setWindowTitle("Python Palette Docker")
# Make a combobox and add palettes
self.cmb_palettes = QComboBox()
allPalettes = Application.resources("palette")
for palette_name in allPalettes:
self.cmb_palettes.addItem(palette_name)
self.cmb_palettes.model().sort(0)
self.currentPalette = Palette(allPalettes[list(allPalettes.keys())[0]])
self.cmb_palettes.currentTextChanged.connect(self.slot_paletteChanged)
layout.addWidget(self.cmb_palettes) # add combobox to the layout
self.paletteView = PaletteView()
self.paletteView.setPalette(self.currentPalette)
layout.addWidget(self.paletteView)
self.paletteView.entrySelectedForeGround.connect(
self.slot_swatchSelected)
self.colorComboBox = QComboBox()
self.colorList = list()
buttonLayout.addWidget(self.colorComboBox)
self.addEntry = QAction(self)
self.addEntry.setIconText("+")
self.addEntry.triggered.connect(self.slot_add_entry)
self.addGroup = QAction(self)
self.addGroup.triggered.connect(self.slot_add_group)
self.addGroup.setText("Add Group")
self.addGroup.setIconText(str("\U0001F4C2"))
self.removeEntry = QAction(self)
self.removeEntry.setText("Remove Entry")
self.removeEntry.setIconText("-")
self.removeEntry.triggered.connect(self.slot_remove_entry)
addEntryButton = QToolButton()
addEntryButton.setDefaultAction(self.addEntry)
buttonLayout.addWidget(addEntryButton)
addGroupButton = QToolButton()
addGroupButton.setDefaultAction(self.addGroup)
buttonLayout.addWidget(addGroupButton)
removeEntryButton = QToolButton()
removeEntryButton.setDefaultAction(self.removeEntry)
buttonLayout.addWidget(removeEntryButton)
# QActions
self.extra = QToolButton()
self.editPaletteData = QAction(self)
self.editPaletteData.setText("Edit Palette Settings")
self.editPaletteData.triggered.connect(self.slot_edit_palette_data)
self.extra.setDefaultAction(self.editPaletteData)
buttonLayout.addWidget(self.extra)
self.actionMenu = QMenu()
self.exportToGimp = QAction(self)
self.exportToGimp.setText("Export as GIMP palette file.")
self.exportToGimp.triggered.connect(self.slot_export_to_gimp_palette)
self.exportToInkscape = QAction(self)
self.exportToInkscape.setText("Export as Inkscape SVG with swatches.")
self.exportToInkscape.triggered.connect(
self.slot_export_to_inkscape_svg)
self.sortColors = QAction(self)
self.sortColors.setText("Sort colors")
self.sortColors.triggered.connect(self.slot_sort_colors)
self.actionMenu.addAction(self.editPaletteData)
self.actionMenu.addAction(self.exportToGimp)
self.actionMenu.addAction(self.exportToInkscape)
self.actionMenu.addAction(self.sortColors)
self.extra.setMenu(self.actionMenu)
layout.addLayout(buttonLayout)
self.slot_fill_combobox()
self.setWidget(widget) # add widget to the docker
def slot_paletteChanged(self, name):
self.currentPalette = Palette(Application.resources("palette")[name])
self.paletteView.setPalette(self.currentPalette)
self.slot_fill_combobox()
@pyqtSlot('KoColorSetEntry')
def slot_swatchSelected(self, entry):
print("entry " + entry.name)
if (self.canvas()) is not None:
if (self.canvas().view()) is not None:
name = entry.name
if len(entry.id) > 0:
name = entry.id + " - " + entry.name
if len(name) > 0:
if name in self.colorList:
self.colorComboBox.setCurrentIndex(
self.colorList.index(name))
color = self.currentPalette.colorForEntry(entry)
self.canvas().view().setForeGroundColor(color)
'''
A function for making a combobox with the available colors. We use QCompleter on the colorComboBox so that people
can type in the name of a color to select it. This is useful for people with carefully made palettes where the colors
are named properly, which makes it easier for them to find colors.
'''
def slot_fill_combobox(self):
if self.currentPalette is None:
pass
palette = self.currentPalette
self.colorComboBox.clear()
self.colorList.clear()
for i in range(palette.colorsCountTotal()):
entry = palette.colorSetEntryByIndex(i)
color = palette.colorForEntry(entry).colorForCanvas(self.canvas())
colorSquare = QPixmap(12, 12)
if entry.spotColor is True:
img = colorSquare.toImage()
circlePainter = QPainter()
img.fill(self.colorComboBox.palette().color(QPalette.Base))
circlePainter.begin(img)
brush = QBrush(Qt.SolidPattern)
brush.setColor(color)
circlePainter.setBrush(brush)
circlePainter.pen().setWidth(0)
circlePainter.drawEllipse(0, 0, 11, 11)
circlePainter.end()
colorSquare = QPixmap.fromImage(img)
else:
colorSquare.fill(color)
name = entry.name
if len(entry.id) > 0:
name = entry.id + " - " + entry.name
self.colorList.append(name)
self.colorComboBox.addItem(QIcon(colorSquare), name)
self.colorComboBox.setEditable(True)
self.colorComboBox.setInsertPolicy(QComboBox.NoInsert)
self.colorComboBox.completer().setCompletionMode(
QCompleter.PopupCompletion)
self.colorComboBox.completer().setCaseSensitivity(False)
self.colorComboBox.completer().setFilterMode(Qt.MatchContains)
self.colorComboBox.currentIndexChanged.connect(
self.slot_get_color_from_combobox)
def slot_get_color_from_combobox(self):
if self.currentPalette is not None:
entry = self.currentPalette.colorSetEntryByIndex(
self.colorComboBox.currentIndex())
self.slot_swatchSelected(entry)
def slot_add_entry(self):
if (self.canvas()) is not None:
if (self.canvas().view()) is not None:
color = self.canvas().view().foreGroundColor()
success = self.paletteView.addEntryWithDialog(color)
if success is True:
self.slot_fill_combobox()
def slot_add_group(self):
success = self.paletteView.addGroupWithDialog()
if success is True:
self.slot_fill_combobox()
def slot_remove_entry(self):
success = self.paletteView.removeSelectedEntryWithDialog()
if success is True:
self.slot_fill_combobox()
'''
A function for giving a gui to edit palette metadata... I also want this to be the way to edit the settings of the
palette docker.
'''
def slot_edit_palette_data(self):
dialog = QDialog(self)
tabWidget = QTabWidget()
dialog.setWindowTitle("Edit Palette Data")
dialog.setLayout(QVBoxLayout())
dialog.layout().addWidget(tabWidget)
paletteWidget = QWidget()
paletteWidget.setLayout(QVBoxLayout())
tabWidget.addTab(paletteWidget, "Palette Data")
paletteName = QLineEdit()
paletteName.setText(self.cmb_palettes.currentText())
paletteWidget.layout().addWidget(paletteName)
paletteColumns = QSpinBox()
paletteColumns.setValue(self.currentPalette.columnCount())
paletteWidget.layout().addWidget(paletteColumns)
paletteComment = QPlainTextEdit()
paletteComment.appendPlainText(self.currentPalette.comment())
paletteWidget.layout().addWidget(paletteComment)
buttons = QDialogButtonBox(QDialogButtonBox.Ok)
dialog.layout().addWidget(buttons)
buttons.accepted.connect(dialog.accept)
# buttons.rejected.connect(dialog.reject())
if dialog.exec_() == QDialog.Accepted:
Resource = Application.resources("palette")[
self.cmb_palettes.currentText()]
Resource.setName(paletteName.text())
self.currentPalette = Palette(Resource)
print(paletteColumns.value())
self.currentPalette.setColumnCount(paletteColumns.value())
self.paletteView.setPalette(self.currentPalette)
self.slot_fill_combobox()
self.currentPalette.setComment(paletteComment.toPlainText())
self.currentPalette.save()
def slot_export_to_gimp_palette(self):
palette_exporter_gimppalette.gimpPaletteExporter(
self.cmb_palettes.currentText())
def slot_export_to_inkscape_svg(self):
palette_exporter_inkscapeSVG.inkscapeSVGExporter(
self.cmb_palettes.currentText())
def slot_sort_colors(self):
colorSorter = palette_sortColors.sortColors(
self.cmb_palettes.currentText())
self.paletteView.setPalette(colorSorter.palette())
def canvasChanged(self, canvas):
pass
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))
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())
class ROPPER(QWidget):
def __init__(self,camID=None,confpath=None,**kwds):
self.isConnected=False
super(ROPPER, self).__init__()
p = pathlib.Path(__file__)
sepa=os.sep
self.conf=QtCore.QSettings(confpath, QtCore.QSettings.IniFormat)
self.icon=str(p.parent) + sepa+'icons' +sepa
self.configMotorPath="./fichiersConfig/"
self.configMotName='configMoteurRSAI.ini'
self.confMotorPath=self.configMotorPath+self.configMotName
self.confMot=QtCore.QSettings(str(p.parent / self.confMotorPath), QtCore.QSettings.IniFormat)
self.confpath=confpath
self.kwds=kwds
self.kwds["conf"]=self.conf
self.kwds["confMot"]=self.confMot
self.setWindowIcon(QIcon(self.icon+'LOA.png'))
self.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
self.iconPlay=pathlib.Path(self.icon+'Play.svg')
self.iconPlay=pathlib.PurePosixPath(self.iconPlay)
self.iconStop=pathlib.Path(self.icon+'Stop.svg')
self.iconStop=pathlib.PurePosixPath(self.iconStop)
self.rot=0
if camID==None: # si None on prend la première...
camID=0
if camID==0:
self.cam="cam0"
if camID==1:
self.cam="cam1"
if camID==2:
self.cam="cam1"
self.camID=int(camID)
# print(self.camID)
self.nbcam=self.cam
self.ccdName=self.conf.value(self.nbcam+"/nameCDD")
self.kwds["name"]=self.nbcam
self.initCam()
self.setup()
self.itrig=0
self.actionButton()
self.camIsRunnig=False
def initCam(self):
# print('init cam')
self.mte = cameraClass.picam()
camProp=self.mte.getAvailableCameras()
print('camera' ,str(self.ccdName))
serialAvailable=camProp[2]
modelAvailable=camProp[0]
self.isConnected=camProp[3]
if self.isConnected==True:
self.serial=self.conf.value(self.nbcam+"/serial")
# print(len(serialAvailable))
if self.serial==serialAvailable[0].decode():
self.camID=0
if len(serialAvailable)>1:
if self.serial==serialAvailable[1].decode():
self.camID=1
if len(serialAvailable)>2:
if self.serial==serialAvailable[2].decode():
self.camID=2
try :
self.mte.connect(self.camID)
self.setWindowTitle(str(self.ccdName)+' '+str(modelAvailable[self.camID])+ ' S/N : '+str(serialAvailable[self.camID].decode())+' v.'+ version)
except :
self.mte.connect(0)
self.setWindowTitle(str(self.ccdName)+ ' S/N :'+str(serialAvailable[0].decode())+' v.'+ version)
self.threadTemp = ThreadTemperature(mte=self.mte)
self.threadTemp.stopTemp=False
self.threadTemp.TEMP.connect(self.update_temp)
self.threadTemp.start()
self.mte.setParameter("CleanCycleCount" , int(1))
self.mte.setParameter("CleanCycleHeight" , int(1))
self.mte.setParameter("ExposureTime" , int(100))
#self.mte.setParameter("TriggerResponse" , int(1)) # pas de trig
self.mte.setParameter("TriggerDetermination", int(1))
self.w = self.mte.getParameter("ActiveWidth")
self.h = self.mte.getParameter("ActiveHeight")
self.mte.setROI(0, self.w, 1, 0, self.h, 1, 0) # full frame
self.mte.sendConfiguration()
self.dimx=self.w
self.dimy=self.h
# print('adc',self.mte.getParameter("AdcSpeed"))
# print('ShutterTimingMode',self.mte.getParameter("ShutterTimingMode"))
self.mte.SetTemperature(20)
self.mte.sendConfiguration()
self.tempWidget=TEMPWIDGET(mte=self.mte)
def update_temp(self, temp=None):
if temp == None:
temp = self.mte.GetTemperature()
self.tempBox.setText('%.1f °C' % temp)
def setup(self):
""" user interface definition:
"""
cameraWidget=QWidget()
vbox1=QVBoxLayout()
self.camName=QLabel(self.ccdName,self)
self.camName.setAlignment(Qt.AlignCenter)
self.camName.setStyleSheet('font :bold 12pt;color: white')
self.camName.setMaximumWidth(80)
vbox1.addWidget(self.camName)
hbox1=QHBoxLayout() # horizontal layout pour run et stop
self.runButton=QPushButton(self)
self.runButton.setMaximumWidth(60)
self.runButton.setMinimumHeight(60)
self.runButton.setStyleSheet("QPushButton:!pressed{border-image: url(%s);background-color: rgb(0, 0, 0,0) ;border-color: green;}""QPushButton:pressed{image: url(%s);background-color: rgb(0, 0, 0,0) ;border-color: rgb(0, 0, 0)}"% (self.iconPlay,self.iconPlay) )
self.stopButton=QPushButton(self)
self.stopButton.setMaximumWidth(60)
self.stopButton.setMinimumHeight(60)
self.stopButton.setStyleSheet("QPushButton:!pressed{border-image: url(%s);background-color: gray ;border-color: rgb(0, 0, 0,0);}""QPushButton:pressed{image: url(%s);background-color: gray ;border-color: rgb(0, 0, 0)}"% (self.iconStop,self.iconStop) )
self.stopButton.setEnabled(False)
hbox1.addWidget(self.runButton)
hbox1.addWidget(self.stopButton)
vbox1.addLayout(hbox1)
self.trigg=QComboBox()
self.trigg.setMaximumWidth(60)
self.trigg.addItem('OFF')
self.trigg.addItem('ON')
self.labelTrigger=QLabel('Trigger')
self.labelTrigger.setMaximumWidth(60)
self.itrig=self.trigg.currentIndex()
hbox2=QHBoxLayout()
hbox2.addWidget(self.labelTrigger)
hbox2.addWidget(self.trigg)
vbox1.addLayout(hbox2)
self.labelExp=QLabel('Exposure (ms)')
self.labelExp.setMaximumWidth(120)
self.labelExp.setAlignment(Qt.AlignCenter)
vbox1.addWidget(self.labelExp)
self.hSliderShutter=QSlider(Qt.Horizontal)
self.hSliderShutter.setMinimum(50)
self.hSliderShutter.setMaximum(100000)
if self.isConnected==True:
self.hSliderShutter.setValue(self.sh)
self.hSliderShutter.setMaximumWidth(80)
self.shutterBox=QSpinBox()
self.shutterBox.setMinimum(50)
self.shutterBox.setMaximum(100000)
if self.isConnected==True:
self.shutterBox.setValue(self.sh)
hboxShutter=QHBoxLayout()
hboxShutter.addWidget(self.hSliderShutter)
hboxShutter.addWidget(self.shutterBox)
vbox1.addLayout(hboxShutter)
hboxTemp=QHBoxLayout()
self.tempButton=QPushButton('Temp')
self.tempButton.setMaximumWidth(80)
hboxTemp.addWidget(self.tempButton)
self.tempBox=QLabel('?')
hboxTemp.addWidget(self.tempBox)
vbox1.addLayout(hboxTemp)
self.settingButton=QPushButton('Settings')
vbox1.addWidget(self.settingButton)
hboxRot=QHBoxLayout()
rotLabel=QLabel('Rotation')
self.rotation=QSpinBox()
self.rotation.setMinimum(0)
self.rotation.setMaximum(4)
hboxRot.addWidget(rotLabel)
hboxRot.addWidget(self.rotation)
vbox1.addLayout(hboxRot)
vbox1.addStretch(1)
cameraWidget.setLayout(vbox1)
cameraWidget.setMinimumSize(150,200)
cameraWidget.setMaximumSize(150,900)
hMainLayout=QHBoxLayout()
hMainLayout.addWidget(cameraWidget)
self.visualisation=SEE2(**self.kwds) ## Widget for visualisation and tools
vbox2=QVBoxLayout()
vbox2.addWidget(self.visualisation)
hMainLayout.addLayout(vbox2)
if self.isConnected==True:
self.settingWidget=SETTINGWIDGET(mte=self.mte,visualisation=self.visualisation)
if self.isConnected==False:
self.runButton.setEnabled(False)
self.runButton.setStyleSheet("QPushButton:!pressed{border-image: url(%s);background-color: gray ;border-color: rgb(0, 0, 0,0);}""QPushButton:pressed{image: url(%s);background-color: gray ;border-color: rgb(0, 0, 0)}"%(self.iconPlay,self.iconPlay))
self.stopButton.setEnabled(False)
self.stopButton.setStyleSheet("QPushButton:!pressed{border-image: url(%s);background-color: gray ;border-color: rgb(0, 0, 0,0);}""QPushButton:pressed{image: url(%s);background-color: gray ;border-color: rgb(0, 0, 0)}"%(self.iconStop,self.iconStop) )
self.trigg.setEnabled(False)
self.hSliderShutter.setEnabled(False)
self.shutterBox.setEnabled(False)
self.setLayout(hMainLayout)
def shutter (self):
'''set exposure time
'''
self.sh=self.shutterBox.value() #
self.hSliderShutter.setValue(self.sh) # set value of slider
self.mte.setParameter("ExposureTime", int(self.sh))
self.mte.sendConfiguration()
time.sleep(0.1)
self.conf.setValue(self.nbcam+"/shutter",float(self.sh))
self.conf.sync()
def mSliderShutter(self): # for shutter slider
self.sh=self.hSliderShutter.value()
self.shutterBox.setValue(self.sh)
self.mte.setParameter("ExposureTime", int(self.sh))
self.mte.sendConfiguration()#
time.sleep(0.1)
self.conf.setValue(self.nbcam+"/shutter",float(self.sh))
def actionButton(self):
'''action when button are pressed
'''
self.runButton.clicked.connect(self.acquireMultiImage)
self.stopButton.clicked.connect(self.stopAcq)
self.shutterBox.editingFinished.connect(self.shutter)
self.hSliderShutter.sliderReleased.connect(self.mSliderShutter)
self.trigg.currentIndexChanged.connect(self.TrigA)
self.tempButton.clicked.connect(lambda:self.open_widget(self.tempWidget) )
self.settingButton.clicked.connect(lambda:self.open_widget(self.settingWidget) )
self.rotation.editingFinished.connect(self.rotfonct)
def acquireMultiImage(self):
''' start the acquisition thread
'''
self.runButton.setEnabled(False)
self.runButton.setStyleSheet("QPushButton:!pressed{border-image: url(%s);background-color: gray ;border-color: rgb(0, 0, 0,0);}""QPushButton:pressed{image: url(%s);background-color: gray ;border-color: rgb(0, 0, 0)}"%(self.iconPlay,self.iconPlay))
self.stopButton.setEnabled(True)
self.stopButton.setStyleSheet("QPushButton:!pressed{border-image: url(%s);background-color: rgb(0, 0, 0,0) ;border-color: rgb(0, 0, 0,0);}""QPushButton:pressed{image: url(%s);background-color: rgb(0, 0, 0,0) ;border-color: rgb(0, 0, 0)}"%(self.iconStop,self.iconStop) )
self.trigg.setEnabled(False)
self.hSliderShutter.setEnabled(False)
self.shutterBox.setEnabled(False)
self.threadRunAcq=ThreadRunAcq(mte=self.mte)
self.threadRunAcq.newDataRun.connect(self.Display)
self.threadRunAcq.start()
self.camIsRunnig=True
def rotfonct(self):
self.rot=self.rotation.value()
def stopAcq(self):
self.mte.StopAcquisition()
try:
self.threadRunAcq.stopThreadRunAcq()
except:
pass
try:
self.threadAcq.terminate()
except:
pass
print('acquisition stopped')
self.runButton.setEnabled(True)
self.runButton.setStyleSheet("QPushButton:!pressed{border-image: url(%s);background-color: rgb(0, 0, 0,0) ;border-color: rgb(0, 0, 0,0);}""QPushButton:pressed{image: url(%s);background-color: rgb(0, 0, 0,0) ;border-color: rgb(0, 0, 0)}"%(self.iconPlay,self.iconPlay))
self.stopButton.setEnabled(False)
self.stopButton.setStyleSheet("QPushButton:!pressed{border-image: url(%s);background-color: gray ;border-color: rgb(0, 0, 0,0);}""QPushButton:pressed{image: url(%s);background-color: gray ;border-color: rgb(0, 0, 0)}"%(self.iconStop,self.iconStop) )
self.trigg.setEnabled(True)
self.hSliderShutter.setEnabled(True)
self.shutterBox.setEnabled(True)
def TrigA(self):
## trig la CCD
itrig=self.trigg.currentIndex()
if itrig==0:
self.mte.setParameter("TriggerResponse", int(1))
self.mte.setParameter("TriggerDetermination", int(1))
self.mte.sendConfiguration()
print ('trigger OFF')
if itrig==1:
#self.mte.setParameter("TriggerSource","TriggerSource_External")
self.mte.setParameter("TriggerResponse", int(2))
self.mte.setParameter("TriggerDetermination", int(1))
self.mte.sendConfiguration()
print ('Trigger ON ')
def Display(self,data):
'''Display data with Visu module
'''
self.data=np.rot90(data,self.rot)
self.visualisation.newDataReceived(self.data) # send data to visualisation widget
def open_widget(self,fene):
""" open new widget
"""
if fene.isWinOpen==False:
#New widget"
fene.show()
fene.isWinOpen=True
else:
#fene.activateWindow()
fene.raise_()
fene.showNormal()
def closeEvent(self,event):
''' closing window event (cross button)
'''
print(' close')
try :
self.threadTemp.stopThreadTemp()
except:
print('no camera connected')
#self.threadTemp.stopThreadTemp()
self.mte.disconnect()
self.mte.unloadLibrary()
time.sleep(0.2)
if self.isConnected==True:
if self.settingWidget.isWinOpen==True:
self.settingWidget.close()
class NetworkChoiceLayout(object):
def __init__(self, network: Network, config: 'SimpleConfig', wizard=False):
self.network = network
self.config = config
self.tor_proxy = None
self.tabs = tabs = QTabWidget()
proxy_tab = QWidget()
blockchain_tab = QWidget()
tabs.addTab(blockchain_tab, _('Overview'))
tabs.addTab(proxy_tab, _('Proxy'))
fixed_width_hostname = 24 * char_width_in_lineedit()
fixed_width_port = 6 * char_width_in_lineedit()
# Proxy tab
grid = QGridLayout(proxy_tab)
grid.setSpacing(8)
# proxy setting
self.proxy_cb = QCheckBox(_('Use proxy'))
self.proxy_cb.clicked.connect(self.check_disable_proxy)
self.proxy_cb.clicked.connect(self.set_proxy)
self.proxy_mode = QComboBox()
self.proxy_mode.addItems(['SOCKS4', 'SOCKS5'])
self.proxy_host = QLineEdit()
self.proxy_host.setFixedWidth(fixed_width_hostname)
self.proxy_port = QLineEdit()
self.proxy_port.setFixedWidth(fixed_width_port)
self.proxy_user = QLineEdit()
self.proxy_user.setPlaceholderText(_("Proxy user"))
self.proxy_password = PasswordLineEdit()
self.proxy_password.setPlaceholderText(_("Password"))
self.proxy_password.setFixedWidth(fixed_width_port)
self.proxy_mode.currentIndexChanged.connect(self.set_proxy)
self.proxy_host.editingFinished.connect(self.set_proxy)
self.proxy_port.editingFinished.connect(self.set_proxy)
self.proxy_user.editingFinished.connect(self.set_proxy)
self.proxy_password.editingFinished.connect(self.set_proxy)
self.proxy_mode.currentIndexChanged.connect(
self.proxy_settings_changed)
self.proxy_host.textEdited.connect(self.proxy_settings_changed)
self.proxy_port.textEdited.connect(self.proxy_settings_changed)
self.proxy_user.textEdited.connect(self.proxy_settings_changed)
self.proxy_password.textEdited.connect(self.proxy_settings_changed)
self.tor_cb = QCheckBox(_("Use Tor Proxy"))
self.tor_cb.setIcon(read_QIcon("tor_logo.png"))
self.tor_cb.hide()
self.tor_cb.clicked.connect(self.use_tor_proxy)
grid.addWidget(self.tor_cb, 1, 0, 1, 3)
grid.addWidget(self.proxy_cb, 2, 0, 1, 3)
grid.addWidget(
HelpButton(
_('Proxy settings apply to all connections: with Electrum-CHI servers, but also with third-party services.'
)), 2, 4)
grid.addWidget(self.proxy_mode, 4, 1)
grid.addWidget(self.proxy_host, 4, 2)
grid.addWidget(self.proxy_port, 4, 3)
grid.addWidget(self.proxy_user, 5, 2)
grid.addWidget(self.proxy_password, 5, 3)
grid.setRowStretch(7, 1)
# Blockchain Tab
grid = QGridLayout(blockchain_tab)
msg = ' '.join([
_("Electrum-CHI connects to several nodes in order to download block headers and find out the longest blockchain."
),
_("This blockchain is used to verify the transactions sent by your transaction server."
)
])
self.status_label = QLabel('')
grid.addWidget(QLabel(_('Status') + ':'), 0, 0)
grid.addWidget(self.status_label, 0, 1, 1, 3)
grid.addWidget(HelpButton(msg), 0, 4)
self.autoconnect_cb = QCheckBox(_('Select server automatically'))
self.autoconnect_cb.setEnabled(
self.config.is_modifiable('auto_connect'))
self.autoconnect_cb.clicked.connect(self.set_server)
self.autoconnect_cb.clicked.connect(self.update)
msg = ' '.join([
_("If auto-connect is enabled, Electrum-CHI will always use a server that is on the longest blockchain."
),
_("If it is disabled, you have to choose a server you want to use. Electrum-CHI will warn you if your server is lagging."
)
])
grid.addWidget(self.autoconnect_cb, 1, 0, 1, 3)
grid.addWidget(HelpButton(msg), 1, 4)
self.server_e = QLineEdit()
self.server_e.setFixedWidth(fixed_width_hostname + fixed_width_port)
self.server_e.editingFinished.connect(self.set_server)
msg = _(
"Electrum-CHI sends your wallet addresses to a single server, in order to receive your transaction history."
)
grid.addWidget(QLabel(_('Server') + ':'), 2, 0)
grid.addWidget(self.server_e, 2, 1, 1, 3)
grid.addWidget(HelpButton(msg), 2, 4)
self.height_label = QLabel('')
msg = _('This is the height of your local copy of the blockchain.')
grid.addWidget(QLabel(_('Blockchain') + ':'), 3, 0)
grid.addWidget(self.height_label, 3, 1)
grid.addWidget(HelpButton(msg), 3, 4)
self.split_label = QLabel('')
grid.addWidget(self.split_label, 4, 0, 1, 3)
self.nodes_list_widget = NodesListWidget(self)
grid.addWidget(self.nodes_list_widget, 6, 0, 1, 5)
vbox = QVBoxLayout()
vbox.addWidget(tabs)
self.layout_ = vbox
# tor detector
self.td = td = TorDetector()
td.found_proxy.connect(self.suggest_proxy)
td.start()
self.fill_in_proxy_settings()
self.update()
def check_disable_proxy(self, b):
if not self.config.is_modifiable('proxy'):
b = False
for w in [
self.proxy_mode, self.proxy_host, self.proxy_port,
self.proxy_user, self.proxy_password
]:
w.setEnabled(b)
def enable_set_server(self):
if self.config.is_modifiable('server'):
enabled = not self.autoconnect_cb.isChecked()
self.server_e.setEnabled(enabled)
else:
for w in [
self.autoconnect_cb, self.server_e, self.nodes_list_widget
]:
w.setEnabled(False)
def update(self):
net_params = self.network.get_parameters()
server = net_params.server
auto_connect = net_params.auto_connect
if not self.server_e.hasFocus():
self.server_e.setText(server.net_addr_str())
self.autoconnect_cb.setChecked(auto_connect)
height_str = "%d " % (self.network.get_local_height()) + _('blocks')
self.height_label.setText(height_str)
n = len(self.network.get_interfaces())
status = _("Connected to {0} nodes.").format(n) if n else _(
"Not connected")
self.status_label.setText(status)
chains = self.network.get_blockchains()
if len(chains) > 1:
chain = self.network.blockchain()
forkpoint = chain.get_max_forkpoint()
name = chain.get_name()
msg = _('Chain split detected at block {0}').format(
forkpoint) + '\n'
msg += (_('You are following branch') if auto_connect else
_('Your server is on branch')) + ' ' + name
msg += ' (%d %s)' % (chain.get_branch_size(), _('blocks'))
else:
msg = ''
self.split_label.setText(msg)
self.nodes_list_widget.update(network=self.network,
servers=self.network.get_servers(),
use_tor=self.tor_cb.isChecked())
self.enable_set_server()
def fill_in_proxy_settings(self):
proxy_config = self.network.get_parameters().proxy
if not proxy_config:
proxy_config = {
"mode": "none",
"host": "localhost",
"port": "9050"
}
b = proxy_config.get('mode') != "none"
self.check_disable_proxy(b)
if b:
self.proxy_cb.setChecked(True)
self.proxy_mode.setCurrentIndex(
self.proxy_mode.findText(str(
proxy_config.get("mode").upper())))
self.proxy_host.setText(proxy_config.get("host"))
self.proxy_port.setText(proxy_config.get("port"))
self.proxy_user.setText(proxy_config.get("user", ""))
self.proxy_password.setText(proxy_config.get("password", ""))
def layout(self):
return self.layout_
def follow_branch(self, chain_id):
self.network.run_from_another_thread(
self.network.follow_chain_given_id(chain_id))
self.update()
def follow_server(self, server: ServerAddr):
self.network.run_from_another_thread(
self.network.follow_chain_given_server(server))
self.update()
def accept(self):
pass
def set_server(self):
net_params = self.network.get_parameters()
try:
server = ServerAddr.from_str_with_inference(
str(self.server_e.text()))
if not server: raise Exception("failed to parse")
except Exception:
return
net_params = net_params._replace(
server=server, auto_connect=self.autoconnect_cb.isChecked())
self.network.run_from_another_thread(
self.network.set_parameters(net_params))
def set_proxy(self):
net_params = self.network.get_parameters()
if self.proxy_cb.isChecked():
proxy = {
'mode': str(self.proxy_mode.currentText()).lower(),
'host': str(self.proxy_host.text()),
'port': str(self.proxy_port.text()),
'user': str(self.proxy_user.text()),
'password': str(self.proxy_password.text())
}
else:
proxy = None
self.tor_cb.setChecked(False)
net_params = net_params._replace(proxy=proxy)
self.network.run_from_another_thread(
self.network.set_parameters(net_params))
def suggest_proxy(self, found_proxy):
if found_proxy is None:
self.tor_cb.hide()
return
self.tor_proxy = found_proxy
self.tor_cb.setText("Use Tor proxy at port " + str(found_proxy[1]))
if (self.proxy_cb.isChecked() and self.proxy_mode.currentIndex()
== self.proxy_mode.findText('SOCKS5')
and self.proxy_host.text() == "127.0.0.1"
and self.proxy_port.text() == str(found_proxy[1])):
self.tor_cb.setChecked(True)
self.tor_cb.show()
def use_tor_proxy(self, use_it):
if not use_it:
self.proxy_cb.setChecked(False)
else:
socks5_mode_index = self.proxy_mode.findText('SOCKS5')
if socks5_mode_index == -1:
_logger.info("can't find proxy_mode 'SOCKS5'")
return
self.proxy_mode.setCurrentIndex(socks5_mode_index)
self.proxy_host.setText("127.0.0.1")
self.proxy_port.setText(str(self.tor_proxy[1]))
self.proxy_user.setText("")
self.proxy_password.setText("")
self.tor_cb.setChecked(True)
self.proxy_cb.setChecked(True)
self.check_disable_proxy(use_it)
self.set_proxy()
def proxy_settings_changed(self):
self.tor_cb.setChecked(False)
class EMPaletteEditor(QWidget):
"""
Editor for the ColorModel. Enables the creation and editing of color
palettes.
This class was the first one created in the project, and as a result
needs to be refactored in order to match the paradigms used later.
"""
colorApplied = pyqtSignal(int, int, int)
colorCanceled = pyqtSignal()
key = ""
def __init__(self, r, g, b):
super(EMPaletteEditor, self).__init__()
layout = QGridLayout()
self.colorList = []
self.paletteTitle = QLineEdit()
self.paletteTitle.textEdited.connect(self.checkCanSave)
self.paletteColors = QComboBox()
self.paletteColors.addItem("*New Color*")
self.paletteColors.currentIndexChanged.connect(self.colorSelected)
self.colorPreview = QWidget()
self.colorPreview.setAutoFillBackground(True)
self.colorName = QLineEdit()
self.colorName.textEdited.connect(self.checkCanBeAdded)
self.rScroll = QSlider(Qt.Horizontal, self)
self.rScroll.setValue(r)
self.rScroll.setMaximum(255)
self.rScroll.valueChanged.connect(self.rSliderChanged)
self.rText = QSpinBox()
self.rText.setValue(g)
self.rText.setMaximum(255)
self.rText.valueChanged.connect(self.rTextChanged)
self.gScroll = QSlider(Qt.Horizontal, self)
self.gScroll.setValue(b)
self.gScroll.setMaximum(255)
self.gScroll.valueChanged.connect(self.gSliderChanged)
self.gText = QSpinBox()
self.gText.setValue(r)
self.gText.setMaximum(255)
self.gText.valueChanged.connect(self.gTextChanged)
self.bScroll = QSlider(Qt.Horizontal, self)
self.bScroll.setValue(g)
self.bScroll.setMaximum(255)
self.bScroll.valueChanged.connect(self.bSliderChanged)
self.bText = QSpinBox()
self.bText.setValue(b)
self.bText.setMaximum(255)
self.bText.valueChanged.connect(self.bTextChanged)
self.addButton = QPushButton("Add")
self.addButton.clicked.connect(self.addUpdateColor)
self.addButton.setEnabled(False)
self.deleteButton = QPushButton("Delete")
self.deleteButton.setEnabled(False)
self.deleteButton.clicked.connect(self.deleteColor)
self.saveButton = QPushButton("Save")
self.saveButton.clicked.connect(self.savePalette)
self.saveButton.setEnabled(False)
self.applyButton = QPushButton("Apply")
self.applyButton.clicked.connect(self.applyColorPick)
self.cancelButton = QPushButton("Cancel")
self.cancelButton.clicked.connect(self.cancelColorPick)
layout.addWidget(QLabel("Palette Title:"), 0, 0)
layout.addWidget(self.paletteTitle, 0, 1, 1, 2)
layout.addWidget(self.colorPreview, 1, 0, 5, 1)
layout.addWidget(QLabel("Colors:"), 1, 1)
layout.addWidget(self.paletteColors, 1, 2)
layout.addWidget(QLabel("Color Title:"), 2, 1)
layout.addWidget(self.colorName, 2, 2)
layout.addWidget(QLabel("R:"), 3, 1)
layout.addWidget(self.rScroll, 3, 2)
layout.addWidget(self.rText, 3, 3)
layout.addWidget(QLabel("G:"), 4, 1)
layout.addWidget(self.gScroll, 4, 2)
layout.addWidget(self.gText, 4, 3)
layout.addWidget(QLabel("B:"), 5, 1)
layout.addWidget(self.bScroll, 5, 2)
layout.addWidget(self.bText, 5, 3)
layout.addWidget(self.addButton, 6, 0)
layout.addWidget(self.deleteButton, 6, 1)
layout.addWidget(self.saveButton, 6, 2)
layout.addWidget(self.applyButton, 7, 0, 1, 2)
layout.addWidget(self.cancelButton, 7, 2, 1, 2)
self.setLayout(layout)
self.loadPaletteFromFile()
self.updatePreviewColor()
def checkCanBeAdded(self):
index = self.paletteColors.currentIndex()
text = self.colorName.text()
if (len(text) > 0):
textIndex = self.paletteColors.findText(self.colorName.text())
if (index == 0):
self.addButton.setEnabled(textIndex == -1)
else:
self.addButton.setEnabled(textIndex == -1
or textIndex == index)
else:
self.addButton.setEnabled(False)
def checkCanSave(self):
self.saveButton.setEnabled(
len(self.paletteTitle.text()) > 0 and len(self.colorList) > 0)
def rSliderChanged(self):
value = self.rScroll.value()
self.rText.setValue(value)
self.updatePreviewColor()
def gSliderChanged(self):
value = self.gScroll.value()
self.gText.setValue(value)
self.updatePreviewColor()
def bSliderChanged(self):
value = self.bScroll.value()
self.bText.setValue(value)
self.updatePreviewColor()
def rTextChanged(self):
value = self.rText.value()
self.rScroll.setValue(value)
self.updatePreviewColor()
def gTextChanged(self):
value = self.gText.value()
self.gScroll.setValue(value)
self.updatePreviewColor()
def bTextChanged(self):
value = self.bText.value()
self.bScroll.setValue(value)
self.updatePreviewColor()
def updatePreviewColor(self):
color = QColor(self.rScroll.value(), self.gScroll.value(),
self.bScroll.value())
palette = QPalette()
palette.setColor(QPalette.Background, color)
self.colorPreview.setPalette(palette)
def addUpdateColor(self):
index = self.paletteColors.currentIndex()
name = self.colorName.text()
rgb = (self.rScroll.value(), self.gScroll.value(),
self.bScroll.value())
if (index == 0):
self.colorList.append(EMColorModel(name, rgb[0], rgb[1], rgb[2]))
self.paletteColors.addItem(name)
self.checkCanSave()
else:
self.paletteColors.setItemText(index, name)
self.colorList[index - 1].setName(name)
self.colorList[index - 1].setColor(rgb[0], rgb[1], rgb[2])
self.checkCanBeAdded()
def colorSelected(self):
index = max(0, self.paletteColors.currentIndex())
if (index == 0):
self.addButton.setText("Add")
self.deleteButton.setEnabled(False)
else:
self.addButton.setText("Update")
self.deleteButton.setEnabled(True)
cm = self.colorList[index - 1]
color = cm.getColor()
self.rScroll.setValue(color.red())
self.gScroll.setValue(color.green())
self.bScroll.setValue(color.blue())
self.colorName.setText(cm.getName())
self.checkCanBeAdded()
def savePalette(self):
paletteName = self.paletteTitle.text()
paletteJS = {"palette_name": paletteName, "colors": []}
for cm in self.colorList:
paletteJS["colors"].append(cm.jsonObj())
# Do fancy stuff to save the palette
text = json.dumps(paletteJS)
f = open("palette.json", "w+")
f.write(text)
f.close()
def deleteColor(self):
index = self.paletteColors.currentIndex()
if (index != 0):
index -= 1
del self.colorList[index]
self.reloadPaletteColors(index)
self.checkCanSave()
def reloadPaletteColors(self, index):
self.paletteColors.clear()
self.paletteColors.addItem("*New Color*")
for cm in self.colorList:
self.paletteColors.addItem(cm.getName())
if (index < self.paletteColors.count()):
self.paletteColors.setCurrentIndex(index)
else:
self.paletteColors.setCurrentIndex(0)
def loadPaletteFromFile(self):
paletteName = ""
paletteColors = []
f = open("palette.json", "r")
if f.mode == 'r':
contents = f.read()
jsContents = json.loads(contents)
f.close()
paletteName = jsContents["palette_name"]
for c in jsContents["colors"]:
paletteColors.append(
EMColorModel(c["name"], c["r"], c["g"], c["b"]))
self.colorList = paletteColors
self.paletteTitle.setText(paletteName)
self.reloadPaletteColors(0)
def applyColorPick(self):
rgb = (self.rScroll.value(), self.gScroll.value(),
self.bScroll.value())
self.colorApplied.emit(rgb[0], rgb[1], rgb[2])
def cancelColorPick(self):
self.colorCanceled.emit()
class GeneralPage(QWidget):
def __init__(self, parent):
super(GeneralPage, self).__init__()
self.parent = parent
self.grid = QVBoxLayout()
self.listeMoteur = ["Google", "Duckduckgo", "Ecosia", "Yahoo", "Bing"]
moteurAcc = self.parent.parent.dbConnection.executewithreturn(
"""SELECT moteur FROM parameters""")[0][0]
for i in range(len(self.listeMoteur)):
if self.listeMoteur[i] == moteurAcc:
self.listeMoteur[i], self.listeMoteur[0] = self.listeMoteur[
0], self.listeMoteur[i]
jsAcc = self.parent.parent.dbConnection.executewithreturn(
"""SELECT js FROM parameters""")[0][0]
if jsAcc == "Activé":
self.listejs = ["Activé", "Désactivé"]
else:
self.listejs = ["Désactivé", "Activé"]
self.lAccueil = QLabel("Page d'accueil")
self.lAccueil.setAlignment(Qt.AlignHCenter)
self.urlAccueil = QLineEdit(
self.parent.parent.dbConnection.executewithreturn(
"""SELECT home FROM parameters""")[0][0])
self.urlAccueil.setAlignment(Qt.AlignHCenter)
self.lMoteur = QLabel("Moteur de recherche")
self.lMoteur.setAlignment(Qt.AlignHCenter)
self.moteurBox = QComboBox()
self.moteurBox.addItems(self.listeMoteur)
self.lJS = QLabel("Javascript")
self.lJS.setAlignment(Qt.AlignHCenter)
self.jsbox = QComboBox()
self.jsbox.addItems(self.listejs)
self.endSpacerItem = QSpacerItem(20, 600)
self.paramSpacerItem = QSpacerItem(20, 25)
self.bValid = PushButton("Valider")
self.bValid.clicked.connect(self.valider)
self.grid.addWidget(self.lAccueil)
self.grid.addWidget(self.urlAccueil)
self.grid.addItem(self.paramSpacerItem)
self.grid.addWidget(self.lMoteur)
self.grid.addWidget(self.moteurBox)
self.grid.addItem(self.paramSpacerItem)
self.grid.addWidget(self.lJS)
self.grid.addWidget(self.jsbox)
self.grid.addItem(self.endSpacerItem)
self.grid.addWidget(self.bValid)
self.setLayout(self.grid)
def valider(self):
parameters = self.parent.parent.dbConnection.executewithreturn(
"""SELECT * FROM parameters""")
self.parent.parent.dbConnection.executewithoutreturn(
"""UPDATE parameters SET home = ? WHERE id = ?""",
(self.urlAccueil.text(), parameters[0][0]))
self.parent.parent.dbConnection.executewithoutreturn(
"""UPDATE parameters SET moteur = ? WHERE id = ?""",
(self.listeMoteur[self.moteurBox.currentIndex()],
parameters[0][0]))
self.parent.parent.dbConnection.executewithoutreturn(
"""UPDATE parameters SET js = ? WHERE id = ?""",
(self.listejs[self.jsbox.currentIndex()], parameters[0][0]))
if self.listejs[self.jsbox.currentIndex()] == "Activé":
QWebEngineSettings.globalSettings().setAttribute(
QWebEngineSettings.JavascriptEnabled, True)
else:
QWebEngineSettings.globalSettings().setAttribute(
QWebEngineSettings.JavascriptEnabled, False)
QMessageBox().about(
self, "Enregistrement fait",
"L'enregistrement des paramètres a été fait sans problème")
class NetworkChoiceLayout(object):
def __init__(self, network: Network, config, wizard=False):
self.network = network
self.config = config
self.protocol = None
self.tor_proxy = None
self.tabs = tabs = QTabWidget()
server_tab = QWidget()
proxy_tab = QWidget()
blockchain_tab = QWidget()
tabs.addTab(blockchain_tab, _('Overview'))
tabs.addTab(server_tab, _('Server'))
tabs.addTab(proxy_tab, _('Proxy'))
# server tab
grid = QGridLayout(server_tab)
grid.setSpacing(8)
self.server_host = QLineEdit()
self.server_host.setFixedWidth(200)
self.server_port = QLineEdit()
self.server_port.setFixedWidth(60)
self.autoconnect_cb = QCheckBox(_('Select server automatically'))
self.autoconnect_cb.setEnabled(
self.config.is_modifiable('auto_connect'))
self.server_host.editingFinished.connect(self.set_server)
self.server_port.editingFinished.connect(self.set_server)
self.autoconnect_cb.clicked.connect(self.set_server)
self.autoconnect_cb.clicked.connect(self.update)
msg = ' '.join([
_("If auto-connect is enabled, Electrum will always use a server that is on the longest blockchain."
),
_("If it is disabled, you have to choose a server you want to use. Electrum will warn you if your server is lagging."
)
])
grid.addWidget(self.autoconnect_cb, 0, 0, 1, 3)
grid.addWidget(HelpButton(msg), 0, 4)
grid.addWidget(QLabel(_('Server') + ':'), 1, 0)
grid.addWidget(self.server_host, 1, 1, 1, 2)
grid.addWidget(self.server_port, 1, 3)
label = _('Server peers') if network.is_connected() else _(
'Default Servers')
grid.addWidget(QLabel(label), 2, 0, 1, 5)
self.servers_list = ServerListWidget(self)
grid.addWidget(self.servers_list, 3, 0, 1, 5)
# Proxy tab
grid = QGridLayout(proxy_tab)
grid.setSpacing(8)
# proxy setting
self.proxy_cb = QCheckBox(_('Use proxy'))
self.proxy_cb.clicked.connect(self.check_disable_proxy)
self.proxy_cb.clicked.connect(self.set_proxy)
self.proxy_mode = QComboBox()
self.proxy_mode.addItems(['SOCKS4', 'SOCKS5'])
self.proxy_host = QLineEdit()
self.proxy_host.setFixedWidth(200)
self.proxy_port = QLineEdit()
self.proxy_port.setFixedWidth(60)
self.proxy_user = QLineEdit()
self.proxy_user.setPlaceholderText(_("Proxy user"))
self.proxy_password = QLineEdit()
self.proxy_password.setPlaceholderText(_("Password"))
self.proxy_password.setEchoMode(QLineEdit.Password)
self.proxy_password.setFixedWidth(60)
self.proxy_mode.currentIndexChanged.connect(self.set_proxy)
self.proxy_host.editingFinished.connect(self.set_proxy)
self.proxy_port.editingFinished.connect(self.set_proxy)
self.proxy_user.editingFinished.connect(self.set_proxy)
self.proxy_password.editingFinished.connect(self.set_proxy)
self.proxy_mode.currentIndexChanged.connect(
self.proxy_settings_changed)
self.proxy_host.textEdited.connect(self.proxy_settings_changed)
self.proxy_port.textEdited.connect(self.proxy_settings_changed)
self.proxy_user.textEdited.connect(self.proxy_settings_changed)
self.proxy_password.textEdited.connect(self.proxy_settings_changed)
self.tor_cb = QCheckBox(_("Use Tor Proxy"))
self.tor_cb.setIcon(read_QIcon("tor_logo.png"))
self.tor_cb.hide()
self.tor_cb.clicked.connect(self.use_tor_proxy)
grid.addWidget(self.tor_cb, 1, 0, 1, 3)
grid.addWidget(self.proxy_cb, 2, 0, 1, 3)
grid.addWidget(
HelpButton(
_('Proxy settings apply to all connections: with Electrum servers, but also with third-party services.'
)), 2, 4)
grid.addWidget(self.proxy_mode, 4, 1)
grid.addWidget(self.proxy_host, 4, 2)
grid.addWidget(self.proxy_port, 4, 3)
grid.addWidget(self.proxy_user, 5, 2)
grid.addWidget(self.proxy_password, 5, 3)
grid.setRowStretch(7, 1)
# Blockchain Tab
grid = QGridLayout(blockchain_tab)
msg = ' '.join([
_("Electrum connects to several nodes in order to download block headers and find out the longest blockchain."
),
_("This blockchain is used to verify the transactions sent by your transaction server."
)
])
self.status_label = QLabel('')
grid.addWidget(QLabel(_('Status') + ':'), 0, 0)
grid.addWidget(self.status_label, 0, 1, 1, 3)
grid.addWidget(HelpButton(msg), 0, 4)
self.server_label = QLabel('')
msg = _(
"Electrum sends your wallet addresses to a single server, in order to receive your transaction history."
)
grid.addWidget(QLabel(_('Server') + ':'), 1, 0)
grid.addWidget(self.server_label, 1, 1, 1, 3)
grid.addWidget(HelpButton(msg), 1, 4)
self.height_label = QLabel('')
msg = _('This is the height of your local copy of the blockchain.')
grid.addWidget(QLabel(_('Blockchain') + ':'), 2, 0)
grid.addWidget(self.height_label, 2, 1)
grid.addWidget(HelpButton(msg), 2, 4)
self.split_label = QLabel('')
grid.addWidget(self.split_label, 3, 0, 1, 3)
self.nodes_list_widget = NodesListWidget(self)
grid.addWidget(self.nodes_list_widget, 5, 0, 1, 5)
vbox = QVBoxLayout()
vbox.addWidget(tabs)
self.layout_ = vbox
# tor detector
self.td = td = TorDetector()
td.found_proxy.connect(self.suggest_proxy)
td.start()
self.fill_in_proxy_settings()
self.update()
def check_disable_proxy(self, b):
if not self.config.is_modifiable('proxy'):
b = False
for w in [
self.proxy_mode, self.proxy_host, self.proxy_port,
self.proxy_user, self.proxy_password
]:
w.setEnabled(b)
def enable_set_server(self):
if self.config.is_modifiable('server'):
enabled = not self.autoconnect_cb.isChecked()
self.server_host.setEnabled(enabled)
self.server_port.setEnabled(enabled)
self.servers_list.setEnabled(enabled)
else:
for w in [
self.autoconnect_cb, self.server_host, self.server_port,
self.servers_list
]:
w.setEnabled(False)
def update(self):
net_params = self.network.get_parameters()
host, port, protocol = net_params.host, net_params.port, net_params.protocol
proxy_config, auto_connect = net_params.proxy, net_params.auto_connect
self.server_host.setText(host)
self.server_port.setText(str(port))
self.autoconnect_cb.setChecked(auto_connect)
interface = self.network.interface
host = interface.host if interface else _('None')
self.server_label.setText(host)
self.set_protocol(protocol)
self.servers = self.network.get_servers()
self.servers_list.update(self.servers, self.protocol,
self.tor_cb.isChecked())
self.enable_set_server()
height_str = "%d " % (self.network.get_local_height()) + _('blocks')
self.height_label.setText(height_str)
n = len(self.network.get_interfaces())
status = _("Connected to {0} nodes.").format(n) if n else _(
"Not connected")
self.status_label.setText(status)
chains = self.network.get_blockchains()
if len(chains) > 1:
chain = self.network.blockchain()
forkpoint = chain.get_max_forkpoint()
name = chain.get_name()
msg = _('Chain split detected at block {0}').format(
forkpoint) + '\n'
msg += (_('You are following branch') if auto_connect else
_('Your server is on branch')) + ' ' + name
msg += ' (%d %s)' % (chain.get_branch_size(), _('blocks'))
else:
msg = ''
self.split_label.setText(msg)
self.nodes_list_widget.update(self.network)
def fill_in_proxy_settings(self):
proxy_config = self.network.get_parameters().proxy
if not proxy_config:
proxy_config = {
"mode": "none",
"host": "localhost",
"port": "9050"
}
b = proxy_config.get('mode') != "none"
self.check_disable_proxy(b)
if b:
self.proxy_cb.setChecked(True)
self.proxy_mode.setCurrentIndex(
self.proxy_mode.findText(str(
proxy_config.get("mode").upper())))
self.proxy_host.setText(proxy_config.get("host"))
self.proxy_port.setText(proxy_config.get("port"))
self.proxy_user.setText(proxy_config.get("user", ""))
self.proxy_password.setText(proxy_config.get("password", ""))
def layout(self):
return self.layout_
def set_protocol(self, protocol):
if protocol != self.protocol:
self.protocol = protocol
def change_protocol(self, use_ssl):
p = 's' if use_ssl else 't'
host = self.server_host.text()
pp = self.servers.get(host, constants.net.DEFAULT_PORTS)
if p not in pp.keys():
p = list(pp.keys())[0]
port = pp[p]
self.server_host.setText(host)
self.server_port.setText(port)
self.set_protocol(p)
self.set_server()
def follow_branch(self, chain_id):
self.network.run_from_another_thread(
self.network.follow_chain_given_id(chain_id))
self.update()
def follow_server(self, server):
self.network.run_from_another_thread(
self.network.follow_chain_given_server(server))
self.update()
def server_changed(self, x):
if x:
self.change_server(str(x.text(0)), self.protocol)
def change_server(self, host, protocol):
pp = self.servers.get(host, constants.net.DEFAULT_PORTS)
if protocol and protocol not in protocol_letters:
protocol = None
if protocol:
port = pp.get(protocol)
if port is None:
protocol = None
if not protocol:
if 's' in pp.keys():
protocol = 's'
port = pp.get(protocol)
else:
protocol = list(pp.keys())[0]
port = pp.get(protocol)
self.server_host.setText(host)
self.server_port.setText(port)
def accept(self):
pass
def set_server(self):
net_params = self.network.get_parameters()
net_params = net_params._replace(
host=str(self.server_host.text()),
port=str(self.server_port.text()),
auto_connect=self.autoconnect_cb.isChecked())
self.network.run_from_another_thread(
self.network.set_parameters(net_params))
def set_proxy(self):
net_params = self.network.get_parameters()
if self.proxy_cb.isChecked():
proxy = {
'mode': str(self.proxy_mode.currentText()).lower(),
'host': str(self.proxy_host.text()),
'port': str(self.proxy_port.text()),
'user': str(self.proxy_user.text()),
'password': str(self.proxy_password.text())
}
else:
proxy = None
self.tor_cb.setChecked(False)
net_params = net_params._replace(proxy=proxy)
self.network.run_from_another_thread(
self.network.set_parameters(net_params))
def suggest_proxy(self, found_proxy):
if found_proxy is None:
self.tor_cb.hide()
return
self.tor_proxy = found_proxy
self.tor_cb.setText("Use Tor proxy at port " + str(found_proxy[1]))
if self.proxy_mode.currentIndex() == self.proxy_mode.findText('SOCKS5') \
and self.proxy_host.text() == "127.0.0.1" \
and self.proxy_port.text() == str(found_proxy[1]):
self.tor_cb.setChecked(True)
self.tor_cb.show()
def use_tor_proxy(self, use_it):
if not use_it:
self.proxy_cb.setChecked(False)
else:
socks5_mode_index = self.proxy_mode.findText('SOCKS5')
if socks5_mode_index == -1:
print_error("[network_dialog] can't find proxy_mode 'SOCKS5'")
return
self.proxy_mode.setCurrentIndex(socks5_mode_index)
self.proxy_host.setText("127.0.0.1")
self.proxy_port.setText(str(self.tor_proxy[1]))
self.proxy_user.setText("")
self.proxy_password.setText("")
self.tor_cb.setChecked(True)
self.proxy_cb.setChecked(True)
self.check_disable_proxy(use_it)
self.set_proxy()
def proxy_settings_changed(self):
self.tor_cb.setChecked(False)
class Capture(QWidget):
def __init__(self):
QWidget.__init__(self)
self.flag = False
bottle_list = getCategories()
self.setWindowTitle("farazist picture")
self.setStyleSheet('background-color: #898989')
# ------------ main ------------
layout = QHBoxLayout()
layout.setSpacing(15)
self.setLayout(layout)
# ------------ left widgets ------------
l_groupbox = QGroupBox()
l_groupbox.setStyleSheet(groupbox_style)
layout.addWidget(l_groupbox)
l_vbox = QVBoxLayout()
l_groupbox.setLayout(l_vbox)
self.image_label = QLabel()
l_vbox.addWidget(self.image_label, alignment=Qt.AlignCenter)
self.timer = QTimer()
self.timer.timeout.connect(self.viewCam)
# ------------ right widgets -----------
r_groupbox = QGroupBox()
r_groupbox.setMaximumWidth(500)
r_groupbox.setStyleSheet(groupbox_style)
layout.addWidget(r_groupbox)
r_vbox = QVBoxLayout()
r_vbox.setSpacing(30)
r_vbox.setContentsMargins(0, 20, 0, 5)
r_groupbox.setLayout(r_vbox)
r_hbox = QHBoxLayout()
r_hbox.setSpacing(5)
self.combo = QComboBox()
self.combo.setStyleSheet(
'background-color: #d5d5d5; selection-background-color: #9a9a9a; font-size: 22px;'
)
self.combo.setFixedSize(450, 40)
self.combo.setLayoutDirection(Qt.RightToLeft)
for i in range(len(bottle_list)):
self.combo.addItem(bottle_list[i])
self.combo.setFont(label_font)
# self.combo.activated[str].connect(self.onChanged)
r_vbox.addWidget(self.combo, alignment=Qt.AlignHCenter)
self.lineEdit = QLineEdit()
self.lineEdit.setPlaceholderText('D:/Farazist project/bottles')
self.lineEdit.setStyleSheet(
'background-color: #d5d5d5; font-size: 18px')
self.lineEdit.setFixedSize(320, 40)
r_hbox.addWidget(self.lineEdit)
self.browse_btn = QPushButton()
self.browse_btn.setStyleSheet(
'background-color: qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:0 #f7f7f8, stop:1 #898c91); color: #373737; font-size: 16px; border: none'
)
self.browse_btn.setFixedSize(100, 40)
self.browse_btn.setText('Browse')
self.browse_btn.clicked.connect(self.setFolder)
r_hbox.addWidget(self.browse_btn)
r_vbox.addLayout(r_hbox)
self.take_btn = QPushButton()
self.take_btn.setFixedSize(110, 110)
self.take_btn.setStyleSheet(btn_style)
self.take_btn.setIcon(QIcon('images/camera.png'))
self.take_btn.setIconSize(QSize(95, 95))
self.take_btn.clicked.connect(self.onChanged)
r_vbox.addWidget(self.take_btn, alignment=Qt.AlignCenter)
label = QLabel(self)
label.setStyleSheet('background-color: none')
pixmap = QPixmap('images/farazist.png')
label.setPixmap(pixmap)
r_vbox.addWidget(label, alignment=Qt.AlignCenter | Qt.AlignBottom)
self.controlTimer()
# self.showMaximized()
def onChanged(self):
if not self.flag:
print('camera is off')
else:
directory = str(self.combo.currentIndex())
parent_dir = "Bottles Images"
path = os.path.join(self.lineEdit.text(), parent_dir, directory)
try:
os.makedirs(path)
print("Directory '% s' created" % directory)
except OSError:
print(("Creation of the directory %s failed" % directory))
name = str(datetime.datetime.now())
name = name.replace(':', '-')
name = name.replace('.', '-')
cv.imwrite(path + '/' + name + '.jpg',
cv.cvtColor(self.image, cv.COLOR_RGB2BGR))
def viewCam(self):
try:
ret, self.image = self.cap.read()
self.image = cv.cvtColor(self.image, cv.COLOR_BGR2RGB)
self.image = cv.flip(self.image, 1)
# get image infos
height, width, channel = self.image.shape
step = channel * width
# create QImage from image
qImg = QImage(self.image.data, width, height, step,
QImage.Format_RGB888)
self.image_label.setPixmap(QPixmap.fromImage(qImg))
except:
self.image_label.setText('Error')
self.image_label.setStyleSheet(
'color: #ffffff; font-size: 40px; background-color: none;')
def controlTimer(self):
# if timer is stopped
if not self.timer.isActive():
self.flag = True
try:
self.cap = cv.VideoCapture(1)
self.timer.start(2)
except:
print('Error')
def setFolder(self):
options = QFileDialog.DontResolveSymlinks | QFileDialog.ShowDirsOnly
folder = QFileDialog.getExistingDirectory(self,
"Open Folder",
self.lineEdit.text(),
options=options)
self.lineEdit.setText(folder)
class AccelerometerV2(COMCUPluginBase):
def __init__(self, *args):
super().__init__(BrickletAccelerometerV2, *args)
self.accelerometer = self.device
self.cbe_acceleration = CallbackEmulator(self.accelerometer.get_acceleration,
None,
self.cb_acceleration,
self.increase_error_count,
expand_result_tuple_for_callback=True)
self.current_acceleration_x = CurveValueWrapper() # float, g
self.current_acceleration_y = CurveValueWrapper() # float, g
self.current_acceleration_z = CurveValueWrapper() # float, g
self.pitch_label = PitchLabel()
self.roll_label = RollLabel()
plots = [('X', Qt.red, self.current_acceleration_x, '{:.4f} g'.format),
('Y', Qt.darkGreen, self.current_acceleration_y, '{:.4f} g'.format),
('Z', Qt.blue, self.current_acceleration_z, '{:.4f} g'.format)]
self.plot_widget = PlotWidget('Acceleration [g]', plots, extra_key_widgets=[self.pitch_label, self.roll_label],
update_interval=0.05, y_resolution=0.0001)
self.fs_label = QLabel('Full Scale:')
self.fs_combo = QComboBox()
self.fs_combo.addItem("2 g")
self.fs_combo.addItem("4 g")
self.fs_combo.addItem("8 g")
self.fs_combo.currentIndexChanged.connect(self.new_config)
self.dr_label = QLabel('Data Rate:')
self.dr_combo = QComboBox()
self.dr_combo.addItem("0.781 Hz")
self.dr_combo.addItem("1.563 Hz")
self.dr_combo.addItem("3.125 Hz")
self.dr_combo.addItem("6.2512 Hz")
self.dr_combo.addItem("12.5 Hz")
self.dr_combo.addItem("25 Hz")
self.dr_combo.addItem("50 Hz")
self.dr_combo.addItem("100 Hz")
self.dr_combo.addItem("200 Hz")
self.dr_combo.addItem("400 Hz")
self.dr_combo.addItem("800 Hz")
self.dr_combo.addItem("1600 Hz")
self.dr_combo.addItem("3200 Hz")
self.dr_combo.addItem("6400 Hz")
self.dr_combo.addItem("12800 Hz")
self.dr_combo.addItem("25600 Hz")
self.dr_combo.currentIndexChanged.connect(self.new_config)
hlayout = QHBoxLayout()
hlayout.addStretch()
hlayout.addWidget(self.fs_label)
hlayout.addWidget(self.fs_combo)
hlayout.addStretch()
hlayout.addWidget(self.dr_label)
hlayout.addWidget(self.dr_combo)
hlayout.addStretch()
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 new_config(self):
dr = self.dr_combo.currentIndex()
fs = self.fs_combo.currentIndex()
self.accelerometer.set_configuration(dr, fs)
def cb_acceleration(self, x, y, z):
self.current_acceleration_x.value = x / 10000.0
self.current_acceleration_y.value = y / 10000.0
self.current_acceleration_z.value = z / 10000.0
self.pitch_label.setText(x, y, z)
self.roll_label.setText(x, y, z)
def get_configuration_async(self, conf):
self.fs_combo.setCurrentIndex(conf.full_scale)
self.dr_combo.setCurrentIndex(conf.data_rate)
def cb_temperature(self, temp):
self.temperature_label.setText(temp)
def start(self):
async_call(self.accelerometer.get_configuration, None, self.get_configuration_async, self.increase_error_count)
self.cbe_acceleration.set_period(50)
self.plot_widget.stop = False
def stop(self):
self.cbe_acceleration.set_period(0)
self.plot_widget.stop = True
def destroy(self):
pass
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickletAccelerometerV2.DEVICE_IDENTIFIER
class SETTINGWIDGET(QWidget):
def __init__(self, mte=None,visualisation=None,parent=None):
super(SETTINGWIDGET, self).__init__(parent)
self.mte=mte
self.visualisation=visualisation
self.isWinOpen=False
self.parent=parent
self.setup()
self.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
self.actionButton()
self.roi1Is=False
def setup(self) :
self.dimx = self.mte.getParameter("ActiveWidth")
self.dimy = self.mte.getParameter("ActiveHeight")
self.setWindowIcon(QIcon('./icons/LOA.png'))
self.setWindowTitle('SETTINGS')
self.vbox=QVBoxLayout()
hboxShutter=QHBoxLayout()
shutterLabel=QLabel('ShutterMode')
self.shutterMode=QComboBox()
self.shutterMode.setMaximumWidth(100)
self.shutterMode.addItem('Normal')
self.shutterMode.addItem('Always Close')
self.shutterMode.addItem('Always Open')
self.shutterMode.addItem('Open before trig')
hboxShutter.addWidget(shutterLabel)
hboxShutter.addWidget(self.shutterMode)
self.vbox.addLayout(hboxShutter)
hboxFrequency=QHBoxLayout()
frequencyLabel=QLabel('Frequency')
self.frequency=QComboBox()
self.frequency.setMaximumWidth(100)
self.frequency.addItem('Normal')
self.frequency.addItem('Always Close')
self.frequency.addItem('Always Open')
hboxFrequency.addWidget(frequencyLabel)
hboxFrequency.addWidget(self.frequency)
self.vbox.addLayout(hboxFrequency)
hboxROI=QHBoxLayout()
hbuttonROI=QVBoxLayout()
self.setROIButton=QPushButton('Set ROI')
self.setROIFullButton=QPushButton('Set full Frame')
self.setROIMouseButton=QPushButton('Mousse')
hbuttonROI.addWidget(self.setROIButton)
hbuttonROI.addWidget(self.setROIFullButton)
hbuttonROI.addWidget(self.setROIMouseButton)
hboxROI.addLayout(hbuttonROI)
roiLay= QVBoxLayout()
labelROIX=QLabel('ROI Xo')
self.ROIX=QDoubleSpinBox(self)
self.ROIX.setMinimum(0)
self.ROIX.setMaximum(self.dimx)
self.ROIY=QDoubleSpinBox(self)
self.ROIY.setMinimum(1)
self.ROIY.setMaximum(self.dimy)
labelROIY=QLabel('ROI Yo')
labelROIW=QLabel('ROI Width')
self.ROIW=QDoubleSpinBox(self)
self.ROIW.setMinimum(0)
self.ROIW.setMaximum(self.dimx)
labelROIH=QLabel('ROI Height')
self.ROIH=QDoubleSpinBox(self)
self.ROIH.setMinimum(1)
self.ROIH.setMaximum(self.dimy)
labelBinX=QLabel('Bin X')
self.BINX=QDoubleSpinBox(self)
self.BINX.setMinimum(1)
self.BINX.setMaximum(self.dimx)
labelBinY=QLabel('Bin Y ')
self.BINY=QDoubleSpinBox(self)
self.BINY.setMinimum(1)
self.BINY.setMaximum(self.dimy)
grid_layout = QGridLayout()
grid_layout.addWidget(labelROIX,0,0)
grid_layout.addWidget(self.ROIX,0,1)
grid_layout.addWidget(labelROIY,1,0)
grid_layout.addWidget(self.ROIY,1,1)
grid_layout.addWidget(labelROIW,2,0)
grid_layout.addWidget(self.ROIW,2,1)
grid_layout.addWidget(labelROIH,3,0)
grid_layout.addWidget(self.ROIH,3,1)
grid_layout.addWidget(labelBinX,4,0)
grid_layout.addWidget(self.BINX,4,1)
grid_layout.addWidget(labelBinY,5,0)
grid_layout.addWidget(self.BINY,5,1)
roiLay.addLayout(grid_layout)
hboxROI.addLayout(roiLay)
self.vbox.addLayout(hboxROI)
self.setLayout(self.vbox)
self.r1=100
self.roi1=pg.RectROI([self.dimx/2,self.dimy/2], [2*self.r1, 2*self.r1],pen='r',movable=True)
self.roi1.setPos([self.dimx/2-self.r1,self.dimy/2-self.r1])
def actionButton(self):
self.setROIButton.clicked.connect(self.roiSet)
self.setROIFullButton.clicked.connect(self.roiFull)
self.frequency.currentIndexChanged.connect(self.setFrequency)
self.shutterMode.currentIndexChanged.connect(self.setShutterMode)
self.setROIMouseButton.clicked.connect(self.mousseROI)
self.roi1.sigRegionChangeFinished.connect(self.moussFinished)
def mousseROI(self):
self.visualisation.p1.addItem(self.roi1)
self.roi1Is=True
def moussFinished(self):
posRoi=self.roi1.pos()
sizeRoi=self.roi1.size()
self.x0=int(posRoi.x())
self.wroi=int(sizeRoi.x())
self.hroi=int(sizeRoi.y())
self.y0=posRoi.y()+sizeRoi.y()
self.ROIX.setValue(self.x0)
self.ROIY.setValue(self.y0)
self.ROIW.setValue(self.wroi)
self.ROIH.setValue(self.hroi)
def roiSet(self):
self.x0=int(self.ROIX.value())
self.y0=int(self.ROIY.value())
self.w=int(self.ROIW.value())
self.h=int(self.ROIH.value())
self.BinX=int(self.BINX.value())
self.binY=int(self.BINY.value())
self.mte.setROI(self.x0, self.w, self.binX, self.y0, self.h, self.binY, 1)
self.mte.sendConfiguration()
if self.roi1Is==True:
self.visualisation.p1.removeItem(self.roi1)
self.roi1Is=False
def roiFull(self):
self.w = self.mte.getParameter("ActiveWidth")
self.h = self.mte.getParameter("ActiveHeight")
# self.ROIX.setValue(0)
# self.ROIY.setValue(0)
# self.ROIW.setValue(self.w)
# self.ROIH.setValue(self.h)
self.mte.setROI(0, self.w, 1, 0, self.h, 1, 0) # full frame
self.mte.sendConfiguration()
print("fullframe")
if self.roi1Is==True:
self.visualisation.p1.removeItem(self.roi1)
self.roi1Is=False
def setFrequency(self) :
"""
set frequency reading in Mhz
"""
ifreq=self.freqency.currentIndex()
if ifreq==0:
self.mte.setParameter("AdcSpeed",0.1)
if ifreq==0:
self.mte.setParameter("AdcSpeed",1)
if ifreq==0:
self.mte.setParameter("AdcSpeed",2)
print('adc frequency(Mhz)',self.mte.getParameter("AdcSpeed"))
def setShutterMode(self):
""" set shutter mode
"""
ishut=self.shutterMode.currentIndex()
print('shutter')
if ishut==0:
self.mte.setParameter("ShutterTimingMode",0)
if ishut==1:
self.mte.setParameter("ShutterTimingMode",1)
if ishut==2:
self.mte.setParameter("ShutterTimingMode",2)
if ishut==3:
self.mte.setParameter("ShutterTimingMode",3)
print('OutputSignal',self.mte.getParameter("ShutterTimingMode"))
def closeEvent(self, event):
""" when closing the window
"""
self.isWinOpen=False
if self.roi1Is==True:
self.visualisation.p1.removeItem(self.roi1)
self.roi1Is=False
time.sleep(0.1)
event.accept()
class ViewOptions(QWidget):
"""Contains all of the user configurable options related to the music player window."""
def __init__(self, parent=None):
"""Initiate the View Options page in the preferences dialog."""
super(ViewOptions, self).__init__(parent)
self.user_config_file = os.path.join(
AppDirs('mosaic', 'Mandeep').user_config_dir, 'settings.toml')
with open(self.user_config_file) as conffile:
config = toml.load(conffile)
dock_config = QGroupBox('Dock Configuration')
self.media_library_view_button = QCheckBox(
'Show Media Library on Start', self)
self.playlist_view_button = QCheckBox('Show Playlist on Start', self)
dock_start_layout = QVBoxLayout()
dock_start_layout.addWidget(self.media_library_view_button)
dock_start_layout.addWidget(self.playlist_view_button)
self.dock_position = QLabel('Dock Position:')
self.dock_left_side = QRadioButton('Left Side')
self.dock_right_side = QRadioButton('Right Side')
dock_position_layout = QHBoxLayout()
dock_position_layout.addWidget(self.dock_position)
dock_position_layout.addWidget(self.dock_left_side)
dock_position_layout.addWidget(self.dock_right_side)
main_dock_layout = QVBoxLayout()
main_dock_layout.addLayout(dock_start_layout)
main_dock_layout.addLayout(dock_position_layout)
dock_config.setLayout(main_dock_layout)
window_config = QGroupBox("Window Configuration")
size_option = QLabel('Window Size', self)
self.dropdown_box = QComboBox()
self.dropdown_box.addItem('900 x 900')
self.dropdown_box.addItem('800 x 800')
self.dropdown_box.addItem('700 x 700')
self.dropdown_box.addItem('600 x 600')
self.dropdown_box.addItem('500 x 500')
self.dropdown_box.addItem('400 x 400')
window_size_layout = QHBoxLayout()
window_size_layout.addWidget(size_option)
window_size_layout.addWidget(self.dropdown_box)
window_config.setLayout(window_size_layout)
main_layout = QVBoxLayout()
main_layout.addWidget(dock_config)
main_layout.addWidget(window_config)
main_layout.addStretch(1)
self.setLayout(main_layout)
self.check_window_size(config)
self.check_media_library(config)
self.check_playlist_dock(config)
self.check_dock_position(config)
self.dropdown_box.currentIndexChanged.connect(
lambda: self.change_size(config))
self.media_library_view_button.clicked.connect(
lambda: self.media_library_view_settings(config))
self.playlist_view_button.clicked.connect(
lambda: self.playlist_view_settings(config))
self.dock_left_side.clicked.connect(
lambda: self.dock_positon_settings(config))
self.dock_right_side.clicked.connect(
lambda: self.dock_positon_settings(config))
def change_size(self, config):
"""Record the change in window size to the settings.toml file."""
if self.dropdown_box.currentIndex() != -1:
config.setdefault(
'view_options',
{})['window_size'] = self.dropdown_box.currentIndex()
with open(self.user_config_file, 'w') as conffile:
toml.dump(config, conffile)
def check_window_size(self, config):
"""Set the dropdown box to the current window size provided by settings.toml."""
self.dropdown_box.setCurrentIndex(
config['view_options']['window_size'])
def media_library_view_settings(self, config):
"""Change the behavior of the Media Library dock widget.
The default setting hides the dock on application start. With this option
checked, the media library dock will show on start.
"""
if self.media_library_view_button.isChecked():
config.setdefault('media_library', {})['show_on_start'] = True
elif not self.media_library_view_button.isChecked():
config.setdefault('media_library', {})['show_on_start'] = False
with open(self.user_config_file, 'w') as conffile:
toml.dump(config, conffile)
def check_media_library(self, config):
"""Set the media library checkbox state from settings.toml."""
self.media_library_view_button.setChecked(
config['media_library']['show_on_start'])
def playlist_view_settings(self, config):
"""Change the behavior of the Playlist dock widget.
The default setting hides the dock on application start. With this option
checked, the playlist dock will show on start.
"""
if self.playlist_view_button.isChecked():
config.setdefault('playlist', {})['show_on_start'] = True
elif not self.playlist_view_button.isChecked():
config.setdefault('playlist', {})['show_on_start'] = False
with open(self.user_config_file, 'w') as conffile:
toml.dump(config, conffile)
def check_playlist_dock(self, config):
"""Set the playlist dock checkbox state from settings.toml."""
self.playlist_view_button.setChecked(
config['playlist']['show_on_start'])
def dock_positon_settings(self, config):
"""Write to the settings.toml the radio button chosen by the user."""
if self.dock_left_side.isChecked():
config.setdefault('dock', {})['position'] = 'left'
elif self.dock_right_side.isChecked():
config.setdefault('dock', {})['position'] = 'right'
with open(self.user_config_file, 'w') as conffile:
toml.dump(config, conffile)
def check_dock_position(self, config):
"""Select the radio button previously chosen by the user in the preferences dialog."""
if config['dock']['position'] == 'left':
self.dock_left_side.setChecked(True)
elif config['dock']['position'] == 'right':
self.dock_right_side.setChecked(True)
class TabLaTeX(Panel_simple):
titre = "Tableaux LaTeX" # Donner un titre a chaque module
def __init__(self, *args, **kw):
Panel_simple.__init__(self, *args, **kw)
self.sizer = QVBoxLayout()
self.entree = LigneCommande(self, longueur = 500, action = self.generer_code)
self.sizer.addWidget(self.entree)
self.sizer_type = QHBoxLayout()
self.type_tableau = QComboBox(self)
self.type_tableau.addItems(["Tableau de variations", "Tableau de signes",
"Tableau de valeurs"])
self.type_tableau.setCurrentIndex(self._param_.mode)
self.sizer_type.addWidget(QLabel("Type de tableau :", self))
self.sizer_type.addWidget(self.type_tableau)
self.sizer_type.addSpacing(15)
self.utiliser_cellspace = QCheckBox("Utiliser le paquetage cellspace.", self)
self.utiliser_cellspace.setChecked(self._param_.utiliser_cellspace)
self.utiliser_cellspace.setToolTip("Le paquetage cellspace évite que "
"certains objets (comme les fractions) touchent les bordures du tableaux.")
self.sizer_type.addSpacing(10)
self.sizer_type.addWidget(self.utiliser_cellspace)
self.derivee = QCheckBox("Dérivée.", self)
self.derivee.setChecked(self._param_.derivee)
self.derivee.setToolTip("Afficher une ligne indiquant le signe de la dérivée.")
self.sizer_type.addSpacing(10)
self.sizer_type.addWidget(self.derivee)
self.limites = QCheckBox("Limites.", self)
self.limites.setChecked(self._param_.limites)
self.limites.setToolTip("Afficher les limites dans le tableau de variations.")
self.sizer_type.addSpacing(10)
self.sizer_type.addWidget(self.limites)
self.decimales_tabvar_tabsign = QSpinBox()
self.decimales_tabvar_tabsign.setRange(-1, 20)
self.decimales_tabvar_tabsign.setSuffix(" décimales")
self.decimales_tabvar_tabsign.setSpecialValueText("Valeurs exactes")
self.decimales_tabvar_tabsign.setValue(self._param_.decimales_tabvar_tabsign)
##self.decimales_tabvar_tabsign.setAccelerated(True)
aide = "Nombre de décimales pour l'affichage des extrema, ou valeur exacte."
self.decimales_tabvar_tabsign.setToolTip(aide)
self.sizer_type.addSpacing(10)
self.sizer_type.addWidget(self.decimales_tabvar_tabsign)
self.decimales_tabval = QSpinBox()
self.decimales_tabval.setRange(0, 20)
self.decimales_tabval.setSuffix(" décimales")
self.decimales_tabval.setValue(self._param_.decimales_tabval)
##self.decimales_tabval.setAccelerated(True)
aide = "Nombre de décimales pour les valeurs du tableau."
self.decimales_tabval.setToolTip(aide)
self.sizer_type.addSpacing(10)
self.sizer_type.addWidget(self.decimales_tabval)
self.sizer_type.addSpacing(15)
self.lbl_formatage = lbl = QLabel("Formatage des résultats :")
self.sizer_type.addWidget(lbl)
self.formatage_images = QLineEdit()
##self.formatage_images.setMinimumWidth(200)
self.formatage_images.setText(self._param_.formatage_images)
aide = "Formatage à appliquer au résultat (VAL est la valeur du résultat)."
lbl.setToolTip(aide)
self.formatage_images.setToolTip(aide)
self.sizer_type.addSpacing(10)
self.sizer_type.addWidget(self.formatage_images)
self.sizer_type.addStretch()
self.sizer.addLayout(self.sizer_type)
box = QGroupBox("Code LaTeX permettant de de générer le tableau", self)
self.bsizer = QVBoxLayout()
box.setLayout(self.bsizer)
self.code_tableau = QTextEdit(self)
self.code_tableau.setMinimumSize(700, 200)
self.code_tableau.setReadOnly(True)
self.bsizer.addWidget(self.code_tableau)
self.copier_code = QPushButton("Copier dans le presse-papier", self)
self.bsizer.addWidget(self.copier_code)
txt = "Pensez à rajouter dans l'entête de votre fichier LaTeX la ligne suivante :"
self.bsizer.addWidget(QLabel(txt, self))
self.sizer_entete = QHBoxLayout()
self.code_entete = QLineEdit(self)
self.code_entete.setMinimumWidth(200)
self.code_entete.setReadOnly(True)
self.code_entete.setText("\\usepackage{tabvar}")
self.sizer_entete.addWidget(self.code_entete)
self.copier_entete = QPushButton("Copier cette ligne", self)
self.sizer_entete.addWidget(self.copier_entete)
self.bsizer.addLayout(self.sizer_entete)
self.sizer.addWidget(box)
self.cb = QCheckBox("Copier automatiquement le code LaTeX dans le presse-papier.", self)
self.cb.setChecked(self._param_.copie_automatique)
self.sizer.addWidget(self.cb)
self.setLayout(self.sizer)
self.adjustSize()
self.type_tableau.currentIndexChanged.connect(self.EvtChoix)
self.EvtChoix()
def copier_code():
return self.vers_presse_papier(self.code_tableau.toPlainText())
self.copier_code.clicked.connect(copier_code)
def copier_entete():
return self.vers_presse_papier(self.code_entete.text())
self.copier_entete.clicked.connect(copier_entete)
def regler_mode_copie():
self._param_.copie_automatique = self.cb.isChecked()
if self._param_.copie_automatique:
copier_code()
self.cb.stateChanged.connect(regler_mode_copie)
def regler_cellspace():
self._param_.utiliser_cellspace = self.utiliser_cellspace.isChecked()
if self._param_.utiliser_cellspace:
self.code_entete.setText("\\usepackage{cellspace}")
else:
self.code_entete.setText("")
self.valider()
self.utiliser_cellspace.stateChanged.connect(regler_cellspace)
def regler_parametres(event=None):
self._param_.derivee = self.derivee.isChecked()
self._param_.limites = self.limites.isChecked()
self._param_.formatage_images = self.formatage_images.text()
self.valider()
def regler_decimales(event=None):
try:
self.focus_widget = app.focusWidget()
self._param_.decimales_tabvar_tabsign = self.decimales_tabvar_tabsign.value()
self._param_.decimales_tabval = self.decimales_tabval.value()
self.valider()
finally:
self.focus_widget = self.entree
self.derivee.stateChanged.connect(regler_parametres)
self.limites.stateChanged.connect(regler_parametres)
self.formatage_images.editingFinished.connect(regler_parametres)
self.decimales_tabvar_tabsign.valueChanged.connect(regler_decimales)
self.decimales_tabval.valueChanged.connect(regler_decimales)
self.focus_widget = self.entree
def activer(self):
Panel_simple.activer(self)
# Actions à effectuer lorsque l'onglet devient actif
self.entree.setFocus()
def generer_code(self, commande, **kw):
if not commande.strip():
return
# Utilisé pour la sauvegarde automatique:x+3
self.modifie = True
try:
if self._param_.mode == 0:
code_latex = tabvar(commande, derivee=self._param_.derivee,
limites=self._param_.limites,
decimales=self._param_.decimales_tabvar_tabsign,
approche=(self._param_.decimales_tabvar_tabsign != -1))
elif self._param_.mode == 1:
code_latex = tabsign(commande, cellspace=self._param_.utiliser_cellspace,
decimales=self._param_.decimales_tabvar_tabsign,
approche=(self._param_.decimales_tabvar_tabsign != -1))
elif self._param_.mode == 2:
code_latex = tabval(commande,
formatage_antecedents=self._param_.formatage_antecedents,
formatage_images=self._param_.formatage_images,
precision=10**-self._param_.decimales_tabval)
else:
warning("Type de tableau non reconnu.")
self.code_tableau.setText(code_latex)
if self._param_.copie_automatique:
self.vers_presse_papier(texte = code_latex)
self.focus_widget.setFocus()
self.message("Le code LaTeX a bien été généré.")
except BaseException as erreur:
self.message("Impossible de générer le code LaTeX. " + message(erreur))
self.code_tableau.setText("<i><b>Erreur.</b> Impossible de générer le code LaTeX.</i>")
self.entree.setFocus()
if param.debug:
raise
def EvtChoix(self, event = None):
self._param_.mode = self.type_tableau.currentIndex()
# Tableaux de variations
if self._param_.mode == 0:
self.code_entete.setText("\\usepackage{tabvar}")
self.entree.setToolTip(tabvar.__doc__)
self.utiliser_cellspace.hide()
self.derivee.show()
self.limites.show()
self.decimales_tabvar_tabsign.show()
self.formatage_images.hide()
self.lbl_formatage.hide()
self.decimales_tabval.hide()
# Tableaux de signes
elif self._param_.mode == 1:
self.utiliser_cellspace.show()
self.derivee.hide()
self.limites.hide()
self.formatage_images.hide()
self.lbl_formatage.hide()
self.decimales_tabvar_tabsign.show()
self.decimales_tabval.hide()
self.entree.setToolTip(tabsign.__doc__)
if self._param_.utiliser_cellspace:
self.code_entete.setText("\\usepackage{cellspace}")
else:
self.code_entete.setText("")
# Tableaux de valeurs
elif self._param_.mode == 2:
self.utiliser_cellspace.hide()
self.derivee.hide()
self.limites.hide()
self.decimales_tabvar_tabsign.hide()
self.decimales_tabval.show()
self.lbl_formatage.show()
self.formatage_images.show()
self.entree.setToolTip(tabval.__doc__)
self.code_entete.setText("")
self.valider()
def valider(self):
try:
self.entree.valider()
except Exception:
print_error()
class NetworkChoiceLayout(object):
def __init__(self, network: Network, config, wizard=False):
self.network = network
self.config = config
self.protocol = None
self.tor_proxy = None
self.tabs = tabs = QTabWidget()
server_tab = QWidget()
proxy_tab = QWidget()
blockchain_tab = QWidget()
tabs.addTab(blockchain_tab, _('Overview'))
tabs.addTab(server_tab, _('Server'))
tabs.addTab(proxy_tab, _('Proxy'))
# server tab
grid = QGridLayout(server_tab)
grid.setSpacing(8)
self.server_host = QLineEdit()
self.server_host.setFixedWidth(200)
self.server_port = QLineEdit()
self.server_port.setFixedWidth(60)
self.autoconnect_cb = QCheckBox(_('Select server automatically'))
self.autoconnect_cb.setEnabled(self.config.is_modifiable('auto_connect'))
self.server_host.editingFinished.connect(self.set_server)
self.server_port.editingFinished.connect(self.set_server)
self.autoconnect_cb.clicked.connect(self.set_server)
self.autoconnect_cb.clicked.connect(self.update)
msg = ' '.join([
_("If auto-connect is enabled, Electrum will always use a server that is on the longest blockchain."),
_("If it is disabled, you have to choose a server you want to use. Electrum will warn you if your server is lagging.")
])
grid.addWidget(self.autoconnect_cb, 0, 0, 1, 3)
grid.addWidget(HelpButton(msg), 0, 4)
grid.addWidget(QLabel(_('Server') + ':'), 1, 0)
grid.addWidget(self.server_host, 1, 1, 1, 2)
grid.addWidget(self.server_port, 1, 3)
label = _('Server peers') if network.is_connected() else _('Default Servers')
grid.addWidget(QLabel(label), 2, 0, 1, 5)
self.servers_list = ServerListWidget(self)
grid.addWidget(self.servers_list, 3, 0, 1, 5)
# Proxy tab
grid = QGridLayout(proxy_tab)
grid.setSpacing(8)
# proxy setting
self.proxy_cb = QCheckBox(_('Use proxy'))
self.proxy_cb.clicked.connect(self.check_disable_proxy)
self.proxy_cb.clicked.connect(self.set_proxy)
self.proxy_mode = QComboBox()
self.proxy_mode.addItems(['SOCKS4', 'SOCKS5'])
self.proxy_host = QLineEdit()
self.proxy_host.setFixedWidth(200)
self.proxy_port = QLineEdit()
self.proxy_port.setFixedWidth(60)
self.proxy_user = QLineEdit()
self.proxy_user.setPlaceholderText(_("Proxy user"))
self.proxy_password = QLineEdit()
self.proxy_password.setPlaceholderText(_("Password"))
self.proxy_password.setEchoMode(QLineEdit.Password)
self.proxy_password.setFixedWidth(60)
self.proxy_mode.currentIndexChanged.connect(self.set_proxy)
self.proxy_host.editingFinished.connect(self.set_proxy)
self.proxy_port.editingFinished.connect(self.set_proxy)
self.proxy_user.editingFinished.connect(self.set_proxy)
self.proxy_password.editingFinished.connect(self.set_proxy)
self.proxy_mode.currentIndexChanged.connect(self.proxy_settings_changed)
self.proxy_host.textEdited.connect(self.proxy_settings_changed)
self.proxy_port.textEdited.connect(self.proxy_settings_changed)
self.proxy_user.textEdited.connect(self.proxy_settings_changed)
self.proxy_password.textEdited.connect(self.proxy_settings_changed)
self.tor_cb = QCheckBox(_("Use Tor Proxy"))
self.tor_cb.setIcon(read_QIcon("tor_logo.png"))
self.tor_cb.hide()
self.tor_cb.clicked.connect(self.use_tor_proxy)
grid.addWidget(self.tor_cb, 1, 0, 1, 3)
grid.addWidget(self.proxy_cb, 2, 0, 1, 3)
grid.addWidget(HelpButton(_('Proxy settings apply to all connections: with Electrum servers, but also with third-party services.')), 2, 4)
grid.addWidget(self.proxy_mode, 4, 1)
grid.addWidget(self.proxy_host, 4, 2)
grid.addWidget(self.proxy_port, 4, 3)
grid.addWidget(self.proxy_user, 5, 2)
grid.addWidget(self.proxy_password, 5, 3)
grid.setRowStretch(7, 1)
# Blockchain Tab
grid = QGridLayout(blockchain_tab)
msg = ' '.join([
_("Electrum connects to several nodes in order to download block headers and find out the longest blockchain."),
_("This blockchain is used to verify the transactions sent by your transaction server.")
])
self.status_label = QLabel('')
grid.addWidget(QLabel(_('Status') + ':'), 0, 0)
grid.addWidget(self.status_label, 0, 1, 1, 3)
grid.addWidget(HelpButton(msg), 0, 4)
self.server_label = QLabel('')
msg = _("Electrum sends your wallet addresses to a single server, in order to receive your transaction history.")
grid.addWidget(QLabel(_('Server') + ':'), 1, 0)
grid.addWidget(self.server_label, 1, 1, 1, 3)
grid.addWidget(HelpButton(msg), 1, 4)
self.height_label = QLabel('')
msg = _('This is the height of your local copy of the blockchain.')
grid.addWidget(QLabel(_('Blockchain') + ':'), 2, 0)
grid.addWidget(self.height_label, 2, 1)
grid.addWidget(HelpButton(msg), 2, 4)
self.split_label = QLabel('')
grid.addWidget(self.split_label, 3, 0, 1, 3)
self.nodes_list_widget = NodesListWidget(self)
grid.addWidget(self.nodes_list_widget, 5, 0, 1, 5)
vbox = QVBoxLayout()
vbox.addWidget(tabs)
self.layout_ = vbox
# tor detector
self.td = td = TorDetector()
td.found_proxy.connect(self.suggest_proxy)
td.start()
self.fill_in_proxy_settings()
self.update()
def check_disable_proxy(self, b):
if not self.config.is_modifiable('proxy'):
b = False
for w in [self.proxy_mode, self.proxy_host, self.proxy_port, self.proxy_user, self.proxy_password]:
w.setEnabled(b)
def enable_set_server(self):
if self.config.is_modifiable('server'):
enabled = not self.autoconnect_cb.isChecked()
self.server_host.setEnabled(enabled)
self.server_port.setEnabled(enabled)
self.servers_list.setEnabled(enabled)
else:
for w in [self.autoconnect_cb, self.server_host, self.server_port, self.servers_list]:
w.setEnabled(False)
def update(self):
net_params = self.network.get_parameters()
host, port, protocol = net_params.host, net_params.port, net_params.protocol
proxy_config, auto_connect = net_params.proxy, net_params.auto_connect
self.server_host.setText(host)
self.server_port.setText(str(port))
self.autoconnect_cb.setChecked(auto_connect)
interface = self.network.interface
host = interface.host if interface else _('None')
self.server_label.setText(host)
self.set_protocol(protocol)
self.servers = self.network.get_servers()
self.servers_list.update(self.servers, self.protocol, self.tor_cb.isChecked())
self.enable_set_server()
height_str = "%d "%(self.network.get_local_height()) + _('blocks')
self.height_label.setText(height_str)
n = len(self.network.get_interfaces())
status = _("Connected to {0} nodes.").format(n) if n else _("Not connected")
self.status_label.setText(status)
chains = self.network.get_blockchains()
if len(chains) > 1:
chain = self.network.blockchain()
forkpoint = chain.get_max_forkpoint()
name = chain.get_name()
msg = _('Chain split detected at block {0}').format(forkpoint) + '\n'
msg += (_('You are following branch') if auto_connect else _('Your server is on branch'))+ ' ' + name
msg += ' (%d %s)' % (chain.get_branch_size(), _('blocks'))
else:
msg = ''
self.split_label.setText(msg)
self.nodes_list_widget.update(self.network)
def fill_in_proxy_settings(self):
proxy_config = self.network.get_parameters().proxy
if not proxy_config:
proxy_config = {"mode": "none", "host": "localhost", "port": "9050"}
b = proxy_config.get('mode') != "none"
self.check_disable_proxy(b)
if b:
self.proxy_cb.setChecked(True)
self.proxy_mode.setCurrentIndex(
self.proxy_mode.findText(str(proxy_config.get("mode").upper())))
self.proxy_host.setText(proxy_config.get("host"))
self.proxy_port.setText(proxy_config.get("port"))
self.proxy_user.setText(proxy_config.get("user", ""))
self.proxy_password.setText(proxy_config.get("password", ""))
def layout(self):
return self.layout_
def set_protocol(self, protocol):
if protocol != self.protocol:
self.protocol = protocol
def change_protocol(self, use_ssl):
p = 's' if use_ssl else 't'
host = self.server_host.text()
pp = self.servers.get(host, constants.net.DEFAULT_PORTS)
if p not in pp.keys():
p = list(pp.keys())[0]
port = pp[p]
self.server_host.setText(host)
self.server_port.setText(port)
self.set_protocol(p)
self.set_server()
def follow_branch(self, chain_id):
self.network.run_from_another_thread(self.network.follow_chain_given_id(chain_id))
self.update()
def follow_server(self, server):
self.network.run_from_another_thread(self.network.follow_chain_given_server(server))
self.update()
def server_changed(self, x):
if x:
self.change_server(str(x.text(0)), self.protocol)
def change_server(self, host, protocol):
pp = self.servers.get(host, constants.net.DEFAULT_PORTS)
if protocol and protocol not in protocol_letters:
protocol = None
if protocol:
port = pp.get(protocol)
if port is None:
protocol = None
if not protocol:
if 's' in pp.keys():
protocol = 's'
port = pp.get(protocol)
else:
protocol = list(pp.keys())[0]
port = pp.get(protocol)
self.server_host.setText(host)
self.server_port.setText(port)
def accept(self):
pass
def set_server(self):
net_params = self.network.get_parameters()
net_params = net_params._replace(host=str(self.server_host.text()),
port=str(self.server_port.text()),
auto_connect=self.autoconnect_cb.isChecked())
self.network.run_from_another_thread(self.network.set_parameters(net_params))
def set_proxy(self):
net_params = self.network.get_parameters()
if self.proxy_cb.isChecked():
proxy = { 'mode':str(self.proxy_mode.currentText()).lower(),
'host':str(self.proxy_host.text()),
'port':str(self.proxy_port.text()),
'user':str(self.proxy_user.text()),
'password':str(self.proxy_password.text())}
else:
proxy = None
self.tor_cb.setChecked(False)
net_params = net_params._replace(proxy=proxy)
self.network.run_from_another_thread(self.network.set_parameters(net_params))
def suggest_proxy(self, found_proxy):
if found_proxy is None:
self.tor_cb.hide()
return
self.tor_proxy = found_proxy
self.tor_cb.setText("Use Tor proxy at port " + str(found_proxy[1]))
if (self.proxy_cb.isChecked()
and self.proxy_mode.currentIndex() == self.proxy_mode.findText('SOCKS5')
and self.proxy_host.text() == "127.0.0.1"
and self.proxy_port.text() == str(found_proxy[1])):
self.tor_cb.setChecked(True)
self.tor_cb.show()
def use_tor_proxy(self, use_it):
if not use_it:
self.proxy_cb.setChecked(False)
else:
socks5_mode_index = self.proxy_mode.findText('SOCKS5')
if socks5_mode_index == -1:
_logger.info("can't find proxy_mode 'SOCKS5'")
return
self.proxy_mode.setCurrentIndex(socks5_mode_index)
self.proxy_host.setText("127.0.0.1")
self.proxy_port.setText(str(self.tor_proxy[1]))
self.proxy_user.setText("")
self.proxy_password.setText("")
self.tor_cb.setChecked(True)
self.proxy_cb.setChecked(True)
self.check_disable_proxy(use_it)
self.set_proxy()
def proxy_settings_changed(self):
self.tor_cb.setChecked(False)
class ohm_gui(QMainWindow):
"the whole app GUI"
def __init__(self, title, parent=None):
"__init__ function"
super().__init__(parent)
self.title = title
self.left = 100
self.top = 100
self.width = 770
self.height = 300
def initUI(self):
"Initilization UI "
self.setGeometry(self.left, self.top, self.width, self.height)
self.setWindowTitle(self.title)
self.setMinimumWidth(self.width)
self.setMinimumHeight(self.height)
self.setMaximumWidth(self.width)
self.setMaximumHeight(self.height)
self.statusBar().showMessage("result logs saved on : " +
str(os.getcwd()) + "/results.txt")
self.inputs()
self.selection()
self.buttons()
self.show()
def inputs(self):
"inputs section"
self.lb1 = QLabel("------", self)
self.lb1.setGeometry(15, 30, 100, 22)
self.lb2 = QLabel("------", self)
self.lb2.setGeometry(15, 70, 100, 22)
self.value1 = QLineEdit(self)
self.value1.setGeometry(100, 30, 100, 22)
self.value1.setToolTip("Number Only")
self.value1.setDisabled(True)
self.value2 = QLineEdit(self)
self.value2.setGeometry(100, 70, 100, 22)
self.value2.setToolTip("Number Only")
self.value2.setDisabled(True)
self.res = QLabel("Res = ------ ", self)
self.res.setFont(QFont("Time", 14))
self.res.setStyleSheet("color:red;")
self.res.setGeometry(10, 190, 500, 100)
def selection(self):
"selection section"
#radio button [select the lost value]
self.resistance = QRadioButton("Resistance")
self.resistance.clicked.connect(self.select_option)
self.voltage = QRadioButton("Voltage")
self.voltage.clicked.connect(self.select_option)
self.current = QRadioButton("Current")
self.current.clicked.connect(self.select_option)
self.power = QRadioButton("Power")
self.power.clicked.connect(self.select_option)
#combo box [for select value to calculate]
self.get_resistance = QComboBox()
self.get_resistance.addItems(
["Voltage and current", "Voltage and Power", "Current and Power"])
self.get_resistance.setMaximumWidth(200)
self.get_resistance.setHidden(True)
self.get_resistance.currentIndexChanged.connect(self.select_sub_option)
self.get_resistance.currentIndexChanged.connect(
self.clear_by_sub_options)
self.get_voltage = QComboBox()
self.get_voltage.addItems([
"Resistance and Current", "Resistance and Power",
"Current and Power"
])
self.get_voltage.setMaximumWidth(200)
self.get_voltage.setHidden(True)
self.get_voltage.currentIndexChanged.connect(self.select_sub_option)
self.get_voltage.currentIndexChanged.connect(self.clear_by_sub_options)
self.get_current = QComboBox()
self.get_current.addItems([
"Voltage and Resistance", "Vlotage and Power",
"Resistance and Power"
])
self.get_current.setMaximumWidth(200)
self.get_current.setHidden(True)
self.get_current.currentIndexChanged.connect(self.select_sub_option)
self.get_current.currentIndexChanged.connect(self.clear_by_sub_options)
self.get_power = QComboBox()
self.get_power.addItems([
"Voltage and Current", "Voltage and Resistance",
"Current and Resistance"
])
self.get_power.setMaximumWidth(200)
self.get_power.setHidden(True)
self.get_power.currentIndexChanged.connect(self.select_sub_option)
self.get_power.currentTextChanged.connect(self.clear_by_sub_options)
#units
self.unit_normal = QRadioButton("Normal")
self.unit_normal.setChecked(True)
self.unit_normal.clicked.connect(self.change_unit)
self.unit_kilo = QRadioButton("Kilo")
self.unit_kilo.clicked.connect(self.change_unit)
self.unit_mega = QRadioButton("Mega")
self.unit_mega.clicked.connect(self.change_unit)
self.unit_giga = QRadioButton("Giga")
self.unit_giga.clicked.connect(self.change_unit)
self.unit_tera = QRadioButton("Tera")
self.unit_tera.clicked.connect(self.change_unit)
#layouts
main_select = QHBoxLayout()
main_select.addWidget(self.resistance)
main_select.addWidget(self.voltage)
main_select.addWidget(self.current)
main_select.addWidget(self.power)
main_selections = QGroupBox("Select Lost Value", self)
main_selections.setGeometry(300, 5, 350, 100)
main_selections.setLayout(main_select)
options = QHBoxLayout()
options.addWidget(self.get_resistance)
options.addWidget(self.get_voltage)
options.addWidget(self.get_current)
options.addWidget(self.get_power)
all_options = QGroupBox("Get by", self)
all_options.setGeometry(300, 110, 350, 100)
all_options.setLayout(options)
units = QVBoxLayout()
units.addWidget(self.unit_normal)
units.addWidget(self.unit_kilo)
units.addWidget(self.unit_mega)
units.addWidget(self.unit_giga)
units.addWidget(self.unit_tera)
all_units = QGroupBox("Result unit", self)
all_units.setGeometry(660, 5, 100, 205)
all_units.setLayout(units)
def buttons(self):
self.calc = QPushButton("Calc", self)
self.calc.move(70, 110)
self.calc.setToolTip("Calculate Values")
self.calc.setDisabled(True)
self.calc.clicked.connect(self.run_calc)
self.clear = QPushButton("Clear", self)
self.clear.move(70, 150)
self.clear.setToolTip("Clear feilds and results")
self.clear.setDisabled(True)
self.clear.clicked.connect(self.clear_input)
about = QPushButton("About", self)
about.move(530, 250)
about.clicked.connect(self.about_app)
quit_ = QPushButton("Quit", self)
quit_.move(650, 250)
quit_.setToolTip("Exit")
quit_.setStyleSheet("background:red;color:white")
quit_.clicked.connect(self.close_app)
#*****************
# OPTIONS ACTION *
#*****************
def enable_all(self):
"enable inputs and calc button"
self.value1.setDisabled(False)
self.value2.setDisabled(False)
self.calc.setDisabled(False)
self.clear.setDisabled(False)
def unhide(self, resistance=True, voltage=True, current=True, power=True):
"exchange hide and unhide option for each selection , [ used by another function ]"
self.get_resistance.setHidden(resistance)
self.get_voltage.setHidden(voltage)
self.get_current.setHidden(current)
self.get_power.setHidden(power)
def type_checked(self):
"return the label of the current type options checked"
if self.resistance.isChecked():
return self.resistance.text()
elif self.voltage.isChecked():
return self.voltage.text()
elif self.current.isChecked():
return self.current.text()
elif self.power.isChecked():
return self.power.text()
def clear_input(self):
self.res.setText("Res = ------ ")
self.value1.clear()
self.value2.clear()
def unit_value(self):
if self.unit_normal.isChecked():
return "normal"
elif self.unit_kilo.isChecked():
return "kilo"
elif self.unit_mega.isChecked():
return "mega"
elif self.unit_giga.isChecked():
return "giga"
elif self.unit_tera.isChecked():
return "tera"
#******************
# SLOTS FUNCTIONS *
#******************
def select_option(self):
"man select [Radio buttons] chose Resistance | Voltage | Current | Power \
to perparing the calculations"
self.enable_all()
self.clear_input()
if self.resistance.isChecked():
self.unhide(resistance=False)
elif self.voltage.isChecked():
self.unhide(voltage=False)
elif self.current.isChecked():
self.unhide(current=False)
elif self.power.isChecked():
self.unhide(power=False)
self.select_sub_option()
def select_sub_option(self):
"sub option for each main option , this function return status of what is main select \
and what is the option , return output in dictionary form"
if self.resistance.isChecked():
if self.get_resistance.currentIndex() == 0:
self.lb1.setText("Voltage")
self.lb2.setText("Current")
elif self.get_resistance.currentIndex() == 1:
self.lb1.setText("Voltage")
self.lb2.setText("Power")
elif self.get_resistance.currentIndex() == 2:
self.lb1.setText("Current")
self.lb2.setText("Power")
status = {
"type": "resistance",
"option": self.get_resistance.currentIndex()
}
elif self.voltage.isChecked():
if self.get_voltage.currentIndex() == 0:
self.lb1.setText("Resistance")
self.lb2.setText("Current")
elif self.get_voltage.currentIndex() == 1:
self.lb1.setText("Resistance")
self.lb2.setText("Power")
elif self.get_voltage.currentIndex() == 2:
self.lb1.setText("Current")
self.lb2.setText("Power")
status = {
"type": "voltage",
"option": self.get_voltage.currentIndex()
}
elif self.current.isChecked():
if self.get_current.currentIndex() == 0:
self.lb1.setText("Voltage")
self.lb2.setText("Resistance")
if self.get_current.currentIndex() == 1:
self.lb1.setText("Voltage")
self.lb2.setText("Power")
if self.get_current.currentIndex() == 2:
self.lb1.setText("Resistance")
self.lb2.setText("Power")
status = {
"type": "current",
"option": self.get_current.currentIndex()
}
elif self.power.isChecked():
if self.get_power.currentIndex() == 0:
self.lb1.setText("Voltage")
self.lb2.setText("Current")
if self.get_power.currentIndex() == 1:
self.lb1.setText("Voltage")
self.lb2.setText("Resistance")
if self.get_power.currentIndex() == 2:
self.lb1.setText("Current")
self.lb2.setText("Resistance")
status = {"type": "power", "option": self.get_power.currentIndex()}
return status
def clear_by_sub_options(self):
self.value1.clear()
self.value2.clear()
self.res.setText("Res = ------ ")
def change_unit(self):
self.run_calc()
def close_app(self):
"close application"
self.close()
def about_app(self):
"application description"
QMessageBox().about(
self, "About Application", "OLC [Ohm Law Calc] Version 0.2 \n\n\
Simple Application to calculate the whole Ohm law \n\n\
[ Resistance | Voltage | Current | Power ]\n\n\
[email protected]")
def run_calc(self):
"run Ohm Law Calculation and set the result in the main window"
v1_string = self.value1.text()
v2_string = self.value2.text()
if not v1_string and not v2_string: #do not nothing if theres input and clicked on calc button
self.res.setText("Res = ------")
return
try: #try to convert input to float , if not show error
v1 = float(v1_string)
v2 = float(v2_string)
except Exception as e:
error = "ERROR : Enter Only Numbers"
with open("result.txt", "a") as f: #save on log file
f.write("\n--------\n\n" + str(datetime.now()) + "\n" +
self.lb1.text() + " = " + self.value1.text() + "\n" +
self.lb2.text() + " = " + self.value2.text() + "\n" +
error + "\nCode : " + str(e))
self.res.setText(error)
return
type_ = self.select_sub_option()["type"]
option = self.select_sub_option()["option"]
#Ohm calculator
try: #run calcularion from ohm class , and check the result , if something wrong > show error and save on log file
self.final = ohm(type_, option, v1, v2).calc_res(
) #return (result , 4th result , name of 4th result)
unit = self.unit_value()
if unit == "normal":
result_text = self.type_checked() + " = " + str(
round(self.final[0], 10)) + self.final[3] + "\n" + str(
self.final[2]) + " = " + str(round(self.final[1],
8)) + self.final[4]
elif unit == "kilo":
result_text = self.type_checked() + " = " + str(
round(self.final[0] / 1000,
10)) + " Kilo" + self.final[3] + "\n" + str(
self.final[2]) + " = " + str(
round(self.final[1] / 1000,
8)) + " Kilo" + self.final[4]
elif unit == "mega":
result_text = self.type_checked() + " = " + str(
round(self.final[0] / 1000000,
10)) + " Mega" + self.final[3] + "\n" + str(
self.final[2]) + " = " + str(
round(self.final[1] / 1000000,
8)) + " Mega" + self.final[4]
elif unit == "giga":
result_text = self.type_checked() + " = " + str(
round(self.final[0] / 1000000000,
10)) + " Giga" + self.final[3] + "\n" + str(
self.final[2]) + " = " + str(
round(self.final[1] / 1000000000,
8)) + " Giga" + self.final[4]
elif unit == "tera":
result_text = self.type_checked() + " = " + str(
round(self.final[0] / 1000000000000,
10)) + " Tera" + self.final[3] + "\n" + str(
self.final[2]) + " = " + str(
round(self.final[1] / 1000000000000,
8)) + " Tera" + self.final[4]
with open("result.txt", "a") as f:
f.write("\n--------\n\n" + str(datetime.now()) + "\n" +
self.lb1.text() + " = " + self.value1.text() + "\n" +
self.lb2.text() + " = " + self.value2.text() + "\n" +
result_text)
self.res.setText(result_text)
except Exception as e:
error = "Math Error : Can not dived zero"
with open("result.txt", "a") as f:
f.write("\n--------\n\n" + str(datetime.now()) + "\n" +
self.lb1.text() + " = " + self.value1.text() + "\n" +
self.lb2.text() + " = " + self.value2.text() + "\n" +
error + "\nCode : " + str(e))
self.res.setText(error)
class ChooseDensity(QWidget):
def __init__(self,
A,
Z,
charge,
item_list=[
'HFB-14', 'Gaussian', 'Woods-Saxon', 'Sao-Paulo-density'
]):
super().__init__()
self.A = A
self.Z = Z
self.pn_choice = charge
self.density_function = None
self.layout = QVBoxLayout()
self.setLayout(self.layout)
self.comboBox = QComboBox()
self.layout.addWidget(self.comboBox)
self.comboBox.addItems(item_list)
self.comboBox.currentIndexChanged.connect(self.change_form)
def change_form(self, ):
try:
self.layout.removeWidget(self.subWidget)
self.subWidget.close()
except:
pass
# For other forms of density
self.subWidget = QWidget()
self.sublayout = QFormLayout()
self.subWidget.setLayout(self.sublayout)
if self.comboBox.currentText() == 'Gaussian':
self.layout.addWidget(self.subWidget)
self.lineEdit_alpha = QLineEdit()
self.sublayout.addRow('alpha', self.lineEdit_alpha)
elif self.comboBox.currentText() == 'Woods-Saxon':
self.layout.addWidget(self.subWidget)
self.lineEdit_R0 = QLineEdit()
self.lineEdit_a0 = QLineEdit()
self.sublayout.addRow('R0', self.lineEdit_R0)
self.sublayout.addRow('a0', self.lineEdit_a0)
elif self.comboBox.currentText() == 'Sao-Paulo-density':
self.layout.addWidget(self.subWidget)
self.lineEdit_R0 = QLineEdit()
self.lineEdit_a0 = QLineEdit()
self.sublayout.addRow('R0', self.lineEdit_R0)
self.sublayout.addRow('a0', self.lineEdit_a0)
(R_p, a_p, R_n, a_n) = Sao_Paulo_density(self.A, self.Z)
if self.pn_choice == 0: #neutron
self.lineEdit_R0.setText('{:.4}'.format(R_n))
self.lineEdit_a0.setText('{:.4}'.format(a_n))
elif self.pn_choice == 1: #neutron
self.lineEdit_R0.setText('{:.4}'.format(R_p))
self.lineEdit_a0.setText('{:.4}'.format(a_p))
def get_density(self, ):
"""
return (interpolating) function of density
in case of HFB-14 --> interpolate density
in case of Gaussian and others
--> need to take additional input parameters
to construct function also need to normalize
"""
if self.pn_choice == 0: norm = self.A - self.Z
if self.pn_choice == 1: norm = self.Z
if self.comboBox.currentIndex() == 0: # HFB-14
try:
(r, rhon, rhop) = DFPot3.read_density(self.Z, self.A)
except:
return (None, -1)
if self.pn_choice == 0: #neutron
self.density_function = DFPot3.interpolating_function(r, rhon)
elif self.pn_choice == 1: #proton
self.density_function = DFPot3.interpolating_function(r, rhop)
return (self.density_function, 0)
elif self.comboBox.currentIndex() == 1: #Gaussian
alpha = float(self.lineEdit_alpha.text())
f_rho = lambda r: DFPot3.shape_Gaussian(r, alpha=alpha)
C = DFPot3.normalize_density(f_rho,
norm,
r_range=(0., 20.),
num_quad=70)
self.density_function = lambda r: DFPot3.shape_Gaussian(
r, alpha=alpha, C=C)
return (self.density_function, 0)
elif self.comboBox.currentIndex() in [2, 3]: #WS or Sao-Paulo
R0 = float(self.lineEdit_R0.text())
a0 = float(self.lineEdit_a0.text())
f_rho = lambda r: DFPot3.shape_WS(r, R0=R0, a0=a0, V0=1.0)
C = DFPot3.normalize_density(f_rho,
norm,
r_range=(0., 20.),
num_quad=70)
self.density_function = lambda r: DFPot3.shape_WS(
r, R0=R0, a0=a0, V0=C)
return (self.density_function, 0)
else: # not-available yet
return (self.density_function, -1)
class Behavior(QWidget):
"""Behavior widget class"""
def __init__(self, parent=None):
super().__init__()
self._preferences = parent
container = QVBoxLayout(self)
# Groups
group_box_onsaving = QGroupBox(
translations.TR_PREFERENCES_EDITOR_BEHAVIOR_ONSAVING)
group_box_indentation = QGroupBox(
translations.TR_PREFERENCES_EDITOR_BEHAVIOR_INDENTATION)
group_box_mouse_kbr = QGroupBox(
translations.TR_PREFERENCES_EDITOR_BEHAVIOR_MOUSE_KEYBOARD)
# On saving
vbox = QVBoxLayout(group_box_onsaving)
self._check_remove_spaces = QCheckBox(
translations.TR_PREFERENCES_EDITOR_BEHAVIOR_CLEAN_WHITESPACES)
vbox.addWidget(self._check_remove_spaces)
self._check_add_new_line = QCheckBox(
translations.TR_PREFERENCES_EDITOR_BEHAVIOR_ADD_NEW_LINE)
vbox.addWidget(self._check_add_new_line)
# Indentation
hbox = QHBoxLayout(group_box_indentation)
self._combo_tab_policy = QComboBox()
self._combo_tab_policy.setSizePolicy(
QSizePolicy.Expanding, QSizePolicy.Fixed)
self._combo_tab_policy.addItems([
translations.TR_PREFERENCES_EDITOR_BEHAVIOR_SPACES_ONLY,
translations.TR_PREFERENCES_EDITOR_BEHAVIOR_TABS_ONLY
])
hbox.addWidget(self._combo_tab_policy)
hbox.addWidget(
QLabel(translations.TR_PREFERENCES_EDITOR_BEHAVIOR_INDENT_SIZE))
self._spin_indent_size = QSpinBox()
hbox.addWidget(self._spin_indent_size)
# Mouse and keyboard
vbox = QVBoxLayout(group_box_mouse_kbr)
self._check_scroll_wheel = QCheckBox(
translations.TR_PREFERENCES_EDITOR_BEHAVIOR_SCROLL_WHEEL)
vbox.addWidget(self._check_scroll_wheel)
self._check_hide_cursor = QCheckBox(
translations.TR_PREFERENCES_EDITOR_BEHAVIOR_HIDE_CURSOR)
vbox.addWidget(self._check_hide_cursor)
hbox = QHBoxLayout()
hbox.addWidget(
QLabel(translations.TR_PREFERENCES_EDITOR_BEHAVIOR_SHOW_TOOLTIPS))
self._combo_tooltips = QComboBox()
self._combo_tooltips.setSizePolicy(
QSizePolicy.Expanding, QSizePolicy.Fixed)
self._combo_tooltips.addItems([
translations.TR_PREFERENCES_EDITOR_BEHAVIOR_TOOLTIPS_MOUSE_OVER,
translations.TR_PREFERENCES_EDITOR_BEHAVIOR_TOOLTIPS_SHIFT
])
hbox.addWidget(self._combo_tooltips)
vbox.addLayout(hbox)
container.addWidget(group_box_onsaving)
container.addWidget(group_box_indentation)
container.addWidget(group_box_mouse_kbr)
container.addStretch(1)
# Settings
self._check_remove_spaces.setChecked(settings.REMOVE_TRAILING_SPACES)
self._check_add_new_line.setChecked(settings.ADD_NEW_LINE_AT_EOF)
self._check_hide_cursor.setChecked(settings.HIDE_MOUSE_CURSOR)
self._check_scroll_wheel.setChecked(settings.SCROLL_WHEEL_ZOMMING)
self._combo_tab_policy.setCurrentIndex(bool(settings.USE_TABS))
self._spin_indent_size.setValue(settings.INDENT)
self._preferences.savePreferences.connect(self._save)
def _save(self):
qsettings = IDE.ninja_settings()
editor_settings = IDE.editor_settings()
qsettings.beginGroup("editor")
editor_settings.beginGroup("editor")
qsettings.beginGroup("behavior")
editor_settings.beginGroup("behavior")
settings.REMOVE_TRAILING_SPACES = self._check_remove_spaces.isChecked()
qsettings.setValue("removeTrailingSpaces",
settings.REMOVE_TRAILING_SPACES)
settings.ADD_NEW_LINE_AT_EOF = self._check_add_new_line.isChecked()
qsettings.setValue("addNewLineAtEnd", settings.ADD_NEW_LINE_AT_EOF)
settings.HIDE_MOUSE_CURSOR = self._check_hide_cursor.isChecked()
qsettings.setValue("hideMouseCursor", settings.HIDE_MOUSE_CURSOR)
settings.SCROLL_WHEEL_ZOMMING = self._check_scroll_wheel.isChecked()
qsettings.setValue("scrollWheelZomming", settings.SCROLL_WHEEL_ZOMMING)
settings.USE_TABS = bool(self._combo_tab_policy.currentIndex())
editor_settings.setValue("use_tabs", settings.USE_TABS)
settings.INDENT = self._spin_indent_size.value()
editor_settings.setValue("indentation_width", settings.INDENT)
qsettings.endGroup()
qsettings.endGroup()
editor_settings.endGroup()
editor_settings.endGroup()
class ProjectTreeColumn(QDialog):
# Signals
dockWidget = pyqtSignal('PyQt_PyObject')
undockWidget = pyqtSignal()
changeTitle = pyqtSignal('PyQt_PyObject', 'QString')
updateLocator = pyqtSignal()
def __init__(self, parent=None):
super(ProjectTreeColumn, self).__init__(parent)
vbox = QVBoxLayout(self)
# vbox.setSizeConstraint(QVBoxLayout.SetDefaultConstraint)
vbox.setContentsMargins(0, 0, 0, 0)
vbox.setSpacing(0)
self._buttons = []
self._combo_project = QComboBox()
self._combo_project.setProperty("border_bottom", True)
self._combo_project.setProperty("gradient", True)
# self._combo_project.setProperty("border", True)
# self._combo_project.setFrame(False)
# self._combo_project.setMinimumHeight(30)
self._combo_project.setContextMenuPolicy(Qt.CustomContextMenu)
vbox.addWidget(self._combo_project)
self._projects_area = QStackedLayout()
logger.debug("This is the projects area")
vbox.addLayout(self._projects_area)
self.projects = []
self._combo_project.currentIndexChanged[int].connect(
self._change_current_project)
self._combo_project.customContextMenuRequested[
'const QPoint&'].connect(self.context_menu_for_root)
connections = (
{
'target': 'main_container',
'signal_name': 'addToProject(QString)',
'slot': self._add_file_to_project
},
{
'target': 'main_container',
'signal_name': 'showFileInExplorer(QString)',
'slot': self._show_file_in_explorer
},
)
IDE.register_service('projects_explorer', self)
IDE.register_signals('projects_explorer', connections)
ExplorerContainer.register_tab(translations.TR_TAB_PROJECTS, self)
# FIXME: Should have a ninja settings object that stores tree state
# FIXME: Or bettter, application data object
# TODO: check this:
# self.connect(ide, SIGNAL("goingDown()"),
# self.tree_projects.shutdown)
# def close_project_signal():
# self.emit(SIGNAL("updateLocator()"))
def install_tab(self):
ide = IDE.get_service('ide')
ui_tools.install_shortcuts(self, actions.PROJECTS_TREE_ACTIONS, ide)
ide.goingDown.connect(self.close)
def load_session_projects(self, projects):
for project in projects:
if os.path.exists(project):
self._open_project_folder(project)
def open_project_folder(self, folderName=None):
if settings.WORKSPACE:
directory = settings.WORKSPACE
else:
directory = os.path.expanduser("~")
if folderName is None:
folderName = QFileDialog.getExistingDirectory(
self, translations.TR_OPEN_PROJECT_DIRECTORY, directory)
logger.debug("Choosing Foldername")
if folderName:
if not file_manager.folder_exists(folderName):
QMessageBox.information(
self, translations.TR_PROJECT_NONEXIST_TITLE,
translations.TR_PROJECT_NONEXIST % folderName)
return
logger.debug("Opening %s" % folderName)
self._open_project_folder(folderName)
def _open_project_folder(self, folderName):
ninjaide = IDE.get_service("ide")
project = NProject(folderName)
qfsm = ninjaide.filesystem.open_project(project)
if qfsm:
self.add_project(project)
self.save_recent_projects(folderName)
# FIXME: show editor area?
# main_container = IDE.get_service('main_container')
# if main_container:
# main_container.show_editor_area()
if len(self.projects) > 1:
title = "%s (%s)" % (translations.TR_TAB_PROJECTS,
len(self.projects))
else:
title = translations.TR_TAB_PROJECTS
self.changeTitle.emit(self, title)
def _add_file_to_project(self, path):
"""Add the file for 'path' in the project the user choose here."""
if self._projects_area.count() > 0:
pathProject = [self.current_project]
addToProject = add_to_project.AddToProject(pathProject, self)
addToProject.exec_()
if not addToProject.pathSelected:
return
main_container = IDE.get_service('main_container')
if not main_container:
return
editorWidget = main_container.get_current_editor()
if not editorWidget.file_path:
name = QInputDialog.getText(
None, translations.TR_ADD_FILE_TO_PROJECT,
translations.TR_FILENAME + ": ")[0]
if not name:
QMessageBox.information(
self, translations.TR_INVALID_FILENAME,
translations.TR_INVALID_FILENAME_ENTER_A_FILENAME)
return
else:
name = file_manager.get_basename(editorWidget.file_path)
new_path = file_manager.create_path(addToProject.pathSelected,
name)
ide_srv = IDE.get_service("ide")
old_file = ide_srv.get_or_create_nfile(path)
new_file = old_file.save(editorWidget.text(), new_path)
#FIXME: Make this file replace the original in the open tab
else:
pass
# Message about no project
def _show_file_in_explorer(self, path):
'''Iterate through the list of available projects and show
the current file in the explorer view for the first
project that contains it (i.e. if the same file is
included in multiple open projects, the path will be
expanded for the first project only).
Note: This slot is connected to the main container's
"showFileInExplorer(QString)" signal.'''
central = IDE.get_service('central_container')
if central and not central.is_lateral_panel_visible():
return
for project in self.projects:
index = project.model().index(path)
if index.isValid():
# This highlights the index in the tree for us
project.scrollTo(index, QAbstractItemView.EnsureVisible)
project.setCurrentIndex(index)
break
def add_project(self, project):
if project not in self.projects:
self._combo_project.addItem(project.name)
ptree = TreeProjectsWidget(project)
self._projects_area.addWidget(ptree)
ptree.closeProject['PyQt_PyObject'].connect(self._close_project)
pmodel = project.model
ptree.setModel(pmodel)
pindex = pmodel.index(pmodel.rootPath())
ptree.setRootIndex(pindex)
self.projects.append(ptree)
current_index = self._projects_area.count()
self._projects_area.setCurrentIndex(current_index - 1)
self._combo_project.setCurrentIndex(current_index - 1)
def _close_project(self, widget):
"""Close the project related to the tree widget."""
index = self._projects_area.currentIndex()
self.projects.remove(widget)
self._projects_area.takeAt(index)
self._combo_project.removeItem(index)
index = self._combo_project.currentIndex()
self._projects_area.setCurrentIndex(index)
ninjaide = IDE.get_service('ide')
ninjaide.filesystem.close_project(widget.project.path)
widget.deleteLater()
if len(self.projects) > 1:
title = "%s (%s)" % (translations.TR_TAB_PROJECTS,
len(self.projects))
else:
title = translations.TR_TAB_PROJECTS
self.changeTitle.emit(self, title)
self.updateLocator.emit()
def _change_current_project(self, index):
self._projects_area.setCurrentIndex(index)
def close_opened_projects(self):
for project in reversed(self.projects):
self._close_project(project)
def save_project(self):
"""Save all the opened files that belongs to the actual project."""
if self._projects_area.count() > 0:
path = self.current_project.path
main_container = IDE.get_service('main_container')
if path and main_container:
main_container.save_project(path)
def create_new_project(self):
wizard = new_project_manager.NewProjectManager(self)
wizard.show()
@property
def current_project(self):
if self._projects_area.count() > 0:
return self._projects_area.currentWidget().project
@property
def current_tree(self):
return self._projects_area.currentWidget()
def set_current_item(self, path):
if self.current_project is not None:
self.current_tree.set_current_item(path)
def save_recent_projects(self, folder):
settings = IDE.data_settings()
recent_project_list = settings.value('recentProjects', {})
#if already exist on the list update the date time
projectProperties = json_manager.read_ninja_project(folder)
name = projectProperties.get('name', '')
description = projectProperties.get('description', '')
if name == '':
name = file_manager.get_basename(folder)
if description == '':
description = translations.TR_NO_DESCRIPTION
if folder in recent_project_list:
properties = recent_project_list[folder]
properties["lastopen"] = QDateTime.currentDateTime()
properties["name"] = name
properties["description"] = description
recent_project_list[folder] = properties
else:
recent_project_list[folder] = {
"name": name,
"description": description,
"isFavorite": False,
"lastopen": QDateTime.currentDateTime()
}
#if the length of the project list it's high that 10 then delete
#the most old
#TODO: add the length of available projects to setting
if len(recent_project_list) > 10:
del recent_project_list[self.find_most_old_open(
recent_project_list)]
settings.setValue('recentProjects', recent_project_list)
def find_most_old_open(self, recent_project_list):
listFounder = []
for recent_project_path, content in list(recent_project_list.items()):
listFounder.append(
(recent_project_path,
int(content["lastopen"].toString("yyyyMMddHHmmzzz"))))
listFounder = sorted(listFounder,
key=lambda date: listFounder[1],
reverse=True) # sort by date last used
return listFounder[0][0]
def reject(self):
if self.parent() is None:
self.dockWidget.emit(self)
def closeEvent(self, event):
self.dockWidget.emit(self)
event.ignore()
def context_menu_for_root(self):
menu = QMenu(self)
path = self.current_tree.project.path
action_add_file = menu.addAction(QIcon(":img/new"),
translations.TR_ADD_NEW_FILE)
action_add_folder = menu.addAction(QIcon(":img/openProj"),
translations.TR_ADD_NEW_FOLDER)
action_create_init = menu.addAction(translations.TR_CREATE_INIT)
# self.connect(action_add_file, SIGNAL("triggered()"),
# lambda: self.current_tree._add_new_file(path))
# self.connect(action_add_folder, SIGNAL("triggered()"),
# lambda: self.current_tree._add_new_folder(path))
# self.connect(action_create_init, SIGNAL("triggered()"),
# lambda: self.current_tree._create_init(path))
# menu.addSeparator()
# actionRunProject = menu.addAction(QIcon(
# ":img/play"), translations.TR_RUN_PROJECT)
# self.connect(actionRunProject, SIGNAL("triggered()"),
# self.current_tree._execute_project)
# if self.current_tree._added_to_console:
# actionRemoveFromConsole = menu.addAction(
# translations.TR_REMOVE_PROJECT_FROM_PYTHON_CONSOLE)
# self.connect(actionRemoveFromConsole, SIGNAL("triggered()"),
# self.current_tree._remove_project_from_console)
# else:
# actionAdd2Console = menu.addAction(
# translations.TR_ADD_PROJECT_TO_PYTHON_CONSOLE)
# self.connect(actionAdd2Console, SIGNAL("triggered()"),
# self.current_tree._add_project_to_console)
# actionShowFileSizeInfo = menu.addAction(translations.TR_SHOW_FILESIZE)
# self.connect(actionShowFileSizeInfo, SIGNAL("triggered()"),
# self.current_tree.show_filesize_info)
# actionProperties = menu.addAction(QIcon(":img/pref"),
# translations.TR_PROJECT_PROPERTIES)
# self.connect(actionProperties, SIGNAL("triggered()"),
# self.current_tree.open_project_properties)
# menu.addSeparator()
action_close = menu.addAction(translations.TR_CLOSE_PROJECT)
action_add_file.triggered.connect(
lambda: self.current_tree._add_new_file(path))
action_add_folder.triggered.connect(
lambda: self.current_tree._add_new_folder(path))
action_close.triggered.connect(self.current_tree._close_project)
# self.connect(action_close, SIGNAL("triggered()"),
# self.current_tree._close_project)
# menu for the project
for m in self.current_tree.extra_menus_by_scope['project']:
if isinstance(m, QMenu):
menu.addSeparator()
menu.addMenu(m)
# show the menu!
menu.exec_(QCursor.pos())
class Window(QWidget):
def __init__(self):
super(Window, self).__init__()
self.renderArea = RenderArea()
self.shapeComboBox = QComboBox()
self.shapeComboBox.addItem("Polygon", RenderArea.Polygon)
self.shapeComboBox.addItem("Rectangle", RenderArea.Rect)
self.shapeComboBox.addItem("Rounded Rectangle", RenderArea.RoundedRect)
self.shapeComboBox.addItem("Ellipse", RenderArea.Ellipse)
self.shapeComboBox.addItem("Pie", RenderArea.Pie)
self.shapeComboBox.addItem("Chord", RenderArea.Chord)
self.shapeComboBox.addItem("Path", RenderArea.Path)
self.shapeComboBox.addItem("Line", RenderArea.Line)
self.shapeComboBox.addItem("Polyline", RenderArea.Polyline)
self.shapeComboBox.addItem("Arc", RenderArea.Arc)
self.shapeComboBox.addItem("Points", RenderArea.Points)
self.shapeComboBox.addItem("Text", RenderArea.Text)
self.shapeComboBox.addItem("Pixmap", RenderArea.Pixmap)
shapeLabel = QLabel("&Shape:")
shapeLabel.setBuddy(self.shapeComboBox)
self.penWidthSpinBox = QSpinBox()
self.penWidthSpinBox.setRange(0, 20)
self.penWidthSpinBox.setSpecialValueText("0 (cosmetic pen)")
penWidthLabel = QLabel("Pen &Width:")
penWidthLabel.setBuddy(self.penWidthSpinBox)
self.penStyleComboBox = QComboBox()
self.penStyleComboBox.addItem("Solid", Qt.SolidLine)
self.penStyleComboBox.addItem("Dash", Qt.DashLine)
self.penStyleComboBox.addItem("Dot", Qt.DotLine)
self.penStyleComboBox.addItem("Dash Dot", Qt.DashDotLine)
self.penStyleComboBox.addItem("Dash Dot Dot", Qt.DashDotDotLine)
self.penStyleComboBox.addItem("None", Qt.NoPen)
penStyleLabel = QLabel("&Pen Style:")
penStyleLabel.setBuddy(self.penStyleComboBox)
self.penCapComboBox = QComboBox()
self.penCapComboBox.addItem("Flat", Qt.FlatCap)
self.penCapComboBox.addItem("Square", Qt.SquareCap)
self.penCapComboBox.addItem("Round", Qt.RoundCap)
penCapLabel = QLabel("Pen &Cap:")
penCapLabel.setBuddy(self.penCapComboBox)
self.penJoinComboBox = QComboBox()
self.penJoinComboBox.addItem("Miter", Qt.MiterJoin)
self.penJoinComboBox.addItem("Bevel", Qt.BevelJoin)
self.penJoinComboBox.addItem("Round", Qt.RoundJoin)
penJoinLabel = QLabel("Pen &Join:")
penJoinLabel.setBuddy(self.penJoinComboBox)
self.brushStyleComboBox = QComboBox()
self.brushStyleComboBox.addItem("Linear Gradient",
Qt.LinearGradientPattern)
self.brushStyleComboBox.addItem("Radial Gradient",
Qt.RadialGradientPattern)
self.brushStyleComboBox.addItem("Conical Gradient",
Qt.ConicalGradientPattern)
self.brushStyleComboBox.addItem("Texture", Qt.TexturePattern)
self.brushStyleComboBox.addItem("Solid", Qt.SolidPattern)
self.brushStyleComboBox.addItem("Horizontal", Qt.HorPattern)
self.brushStyleComboBox.addItem("Vertical", Qt.VerPattern)
self.brushStyleComboBox.addItem("Cross", Qt.CrossPattern)
self.brushStyleComboBox.addItem("Backward Diagonal", Qt.BDiagPattern)
self.brushStyleComboBox.addItem("Forward Diagonal", Qt.FDiagPattern)
self.brushStyleComboBox.addItem("Diagonal Cross", Qt.DiagCrossPattern)
self.brushStyleComboBox.addItem("Dense 1", Qt.Dense1Pattern)
self.brushStyleComboBox.addItem("Dense 2", Qt.Dense2Pattern)
self.brushStyleComboBox.addItem("Dense 3", Qt.Dense3Pattern)
self.brushStyleComboBox.addItem("Dense 4", Qt.Dense4Pattern)
self.brushStyleComboBox.addItem("Dense 5", Qt.Dense5Pattern)
self.brushStyleComboBox.addItem("Dense 6", Qt.Dense6Pattern)
self.brushStyleComboBox.addItem("Dense 7", Qt.Dense7Pattern)
self.brushStyleComboBox.addItem("None", Qt.NoBrush)
brushStyleLabel = QLabel("&Brush Style:")
brushStyleLabel.setBuddy(self.brushStyleComboBox)
otherOptionsLabel = QLabel("Other Options:")
self.antialiasingCheckBox = QCheckBox("&Antialiasing")
self.transformationsCheckBox = QCheckBox("&Transformations")
self.shapeComboBox.activated.connect(self.shapeChanged)
self.penWidthSpinBox.valueChanged.connect(self.penChanged)
self.penStyleComboBox.activated.connect(self.penChanged)
self.penCapComboBox.activated.connect(self.penChanged)
self.penJoinComboBox.activated.connect(self.penChanged)
self.brushStyleComboBox.activated.connect(self.brushChanged)
self.antialiasingCheckBox.toggled.connect(self.renderArea.setAntialiased)
self.transformationsCheckBox.toggled.connect(self.renderArea.setTransformed)
mainLayout = QGridLayout()
mainLayout.setColumnStretch(0, 1)
mainLayout.setColumnStretch(3, 1)
mainLayout.addWidget(self.renderArea, 0, 0, 1, 4)
mainLayout.setRowMinimumHeight(1, 6)
mainLayout.addWidget(shapeLabel, 2, 1, Qt.AlignRight)
mainLayout.addWidget(self.shapeComboBox, 2, 2)
mainLayout.addWidget(penWidthLabel, 3, 1, Qt.AlignRight)
mainLayout.addWidget(self.penWidthSpinBox, 3, 2)
mainLayout.addWidget(penStyleLabel, 4, 1, Qt.AlignRight)
mainLayout.addWidget(self.penStyleComboBox, 4, 2)
mainLayout.addWidget(penCapLabel, 5, 1, Qt.AlignRight)
mainLayout.addWidget(self.penCapComboBox, 5, 2)
mainLayout.addWidget(penJoinLabel, 6, 1, Qt.AlignRight)
mainLayout.addWidget(self.penJoinComboBox, 6, 2)
mainLayout.addWidget(brushStyleLabel, 7, 1, Qt.AlignRight)
mainLayout.addWidget(self.brushStyleComboBox, 7, 2)
mainLayout.setRowMinimumHeight(8, 6)
mainLayout.addWidget(otherOptionsLabel, 9, 1, Qt.AlignRight)
mainLayout.addWidget(self.antialiasingCheckBox, 9, 2)
mainLayout.addWidget(self.transformationsCheckBox, 10, 2)
self.setLayout(mainLayout)
self.shapeChanged()
self.penChanged()
self.brushChanged()
self.antialiasingCheckBox.setChecked(True)
self.setWindowTitle("Basic Drawing")
def shapeChanged(self):
shape = self.shapeComboBox.itemData(self.shapeComboBox.currentIndex(),
IdRole)
self.renderArea.setShape(shape)
def penChanged(self):
width = self.penWidthSpinBox.value()
style = Qt.PenStyle(self.penStyleComboBox.itemData(
self.penStyleComboBox.currentIndex(), IdRole))
cap = Qt.PenCapStyle(self.penCapComboBox.itemData(
self.penCapComboBox.currentIndex(), IdRole))
join = Qt.PenJoinStyle(self.penJoinComboBox.itemData(
self.penJoinComboBox.currentIndex(), IdRole))
self.renderArea.setPen(QPen(Qt.blue, width, style, cap, join))
def brushChanged(self):
style = Qt.BrushStyle(self.brushStyleComboBox.itemData(
self.brushStyleComboBox.currentIndex(), IdRole))
if style == Qt.LinearGradientPattern:
linearGradient = QLinearGradient(0, 0, 100, 100)
linearGradient.setColorAt(0.0, Qt.white)
linearGradient.setColorAt(0.2, Qt.green)
linearGradient.setColorAt(1.0, Qt.black)
self.renderArea.setBrush(QBrush(linearGradient))
elif style == Qt.RadialGradientPattern:
radialGradient = QRadialGradient(50, 50, 50, 70, 70)
radialGradient.setColorAt(0.0, Qt.white)
radialGradient.setColorAt(0.2, Qt.green)
radialGradient.setColorAt(1.0, Qt.black)
self.renderArea.setBrush(QBrush(radialGradient))
elif style == Qt.ConicalGradientPattern:
conicalGradient = QConicalGradient(50, 50, 150)
conicalGradient.setColorAt(0.0, Qt.white)
conicalGradient.setColorAt(0.2, Qt.green)
conicalGradient.setColorAt(1.0, Qt.black)
self.renderArea.setBrush(QBrush(conicalGradient))
elif style == Qt.TexturePattern:
self.renderArea.setBrush(QBrush(QPixmap(':/images/brick.png')))
else:
self.renderArea.setBrush(QBrush(Qt.green, style))
class Window(QMainWindow):
def __init__(self):
super(Window, self).__init__()
globals.init()
self.initUI()
def initUI(self):
self.resize(800, 600)
self.centre()
# Set background colour of main window to white
palette = QPalette()
palette.setColor(QPalette.Background,Qt.white)
self.setPalette(palette)
self.setWindowTitle('SPE Moto | Induction Motor Parameter Estimation Tool')
self.setWindowIcon(QIcon('icons\motor.png'))
"""
Actions
"""
exitAction = QAction(QIcon('icons\exit.png'), '&Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(QApplication.instance().quit)
loadAction = QAction('&Open File...', self)
loadAction.setStatusTip('Open file and load motor data')
loadAction.triggered.connect(self.load_action)
saveAction = QAction('&Save As...', self)
saveAction.setStatusTip('Save motor data')
saveAction.triggered.connect(self.save_action)
aboutAction = QAction('&About Moto', self)
aboutAction.setStatusTip('About Moto')
aboutAction.triggered.connect(self.about_dialog)
helpAction = QAction('&User Manual', self)
helpAction.setShortcut('F1')
helpAction.setStatusTip('Moto user documentation')
helpAction.triggered.connect(self.user_manual)
"""
Menubar
"""
menu_bar = self.menuBar()
fileMenu = menu_bar.addMenu('&File')
fileMenu.addAction(loadAction)
fileMenu.addAction(saveAction)
fileMenu.addAction(exitAction)
helpMenu = menu_bar.addMenu('&Help')
helpMenu.addAction(helpAction)
helpMenu.addSeparator()
helpMenu.addAction(aboutAction)
"""
Main Screen
"""
heading_font = QFont()
heading_font.setPointSize(10)
heading_font.setBold(True)
################
# Motor details
################
header1 = QLabel('Motor')
#header1.setMinimumWidth(50)
header1.setMinimumHeight(30)
header1.setFont(heading_font)
label1 = QLabel('Description')
#label1.setMinimumWidth(50)
self.le1 = QLineEdit()
#self.le1.setMinimumWidth(150)
self.le1.setText(str(globals.motor_data["description"]))
label2 = QLabel('Synchronous speed')
#label2.setMinimumWidth(50)
self.le2 = QLineEdit()
#self.le2.setMinimumWidth(50)
self.le2.setText(str(globals.motor_data["sync_speed"]))
label2a = QLabel('rpm')
#label2a.setMinimumWidth(30)
label3 = QLabel('Rated speed')
#label3.setMinimumWidth(50)
self.le3 = QLineEdit()
#self.le3.setMinimumWidth(50)
self.le3.setText(str(globals.motor_data["rated_speed"]))
label3a = QLabel('rpm')
#label3a.setMinimumWidth(30)
label4 = QLabel('Rated power factor')
#label4.setMinimumWidth(50)
self.le4 = QLineEdit()
#self.le4.setMinimumWidth(50)
self.le4.setText(str(globals.motor_data["rated_pf"]))
label4a = QLabel('pf')
#label4a.setMinimumWidth(20)
label5 = QLabel('Rated efficiency')
#label5.setMinimumWidth(50)
self.le5 = QLineEdit()
#self.le5.setMinimumWidth(50)
self.le5.setText(str(globals.motor_data["rated_eff"]))
label5a = QLabel('pu')
#label5a.setMinimumWidth(20)
label6 = QLabel('Breakdown torque')
#label6.setMinimumWidth(50)
self.le6 = QLineEdit()
#self.le6.setMinimumWidth(50)
self.le6.setText(str(globals.motor_data["T_b"]))
label6a = QLabel('T/Tn')
#label6a.setMinimumWidth(40)
label7 = QLabel('Locked rotor torque')
#label7.setMinimumWidth(50)
self.le7 = QLineEdit()
#self.le7.setMinimumWidth(50)
self.le7.setText(str(globals.motor_data["T_lr"]))
label7a = QLabel('T/Tn')
#label7a.setMinimumWidth(40)
label8 = QLabel('Locked rotor current')
#label8.setMinimumWidth(50)
self.le8 = QLineEdit()
#self.le8.setMinimumWidth(50)
self.le8.setText(str(globals.motor_data["I_lr"]))
label8a = QLabel('pu')
#label8a.setMinimumWidth(40)
label_rp = QLabel('Rated Power')
self.lex9 = QLineEdit()
self.lex9.setText(str(globals.motor_data["rated_power"]))
labelex9 = QLabel('Kw')
label_ri = QLabel('Rated Current')
self.lex10 = QLineEdit()
self.lex10.setText(str(globals.motor_data["rated_current"]))
labelex10 = QLabel('I')
label_rv = QLabel('Rated Voltage')
self.lex11 = QLineEdit()
self.lex11.setText(str(globals.motor_data["rated_voltage"]))
labelex11 = QLabel('V')
########
# Model
########
header2 = QLabel('Model')
header2.setMinimumHeight(40)
header2.setFont(heading_font)
label_model = QLabel('Model')
#label_model.setMinimumWidth(150)
self.combo_model = QComboBox()
self.combo_model.addItem("Single cage")
# self.combo_model.addItem("Single cage w/o core losses")
self.combo_model.addItem("Double cage")
self.combo_model.setCurrentIndex(1)
self.img1 = QLabel()
self.img1.setPixmap(QPixmap('images\dbl_cage.png'))
#####################
# Algorithm settings
#####################
header3 = QLabel('Settings')
header3.setMinimumHeight(40)
header3.setFont(heading_font)
label9 = QLabel('Maximum # iterations')
self.le9 = QLineEdit()
self.le9.setText(str(globals.algo_data["max_iter"]))
self.le9.setStatusTip('Maximum number of iterations allowed')
label10 = QLabel('Convergence criterion')
self.le10 = QLineEdit()
self.le10.setText(str(globals.algo_data["conv_err"]))
self.le10.setStatusTip('Squared error required to qualify for convergence')
self.label11 = QLabel('Linear constraint k_r')
self.le11 = QLineEdit()
self.le11.setText(str(globals.algo_data["k_r"]))
self.le11.setStatusTip('Linear constraint for Rs')
self.label12 = QLabel('Linear constraint k_x')
self.le12 = QLineEdit()
self.le12.setText(str(globals.algo_data["k_x"]))
self.le12.setStatusTip('Linear constraint for Xr2')
# Genetic Algorithm Widgets
############################
self.labeln_gen = QLabel('Maximum # generations')
self.labeln_gen.setVisible(0)
self.labelpop = QLabel('Members in population')
self.labelpop.setVisible(0)
self.labeln_r = QLabel('Members in mating pool')
self.labeln_r.setVisible(0)
self.labeln_e = QLabel('Elite children')
self.labeln_e.setVisible(0)
self.labelc_f = QLabel('Crossover fraction')
self.labelc_f.setVisible(0)
self.len_gen = QLineEdit()
self.len_gen.setText(str(globals.algo_data["n_gen"]))
self.len_gen.setStatusTip('Maximum number of generations allowed')
self.len_gen.hide()
self.lepop = QLineEdit()
self.lepop.setText(str(globals.algo_data["pop"]))
self.lepop.setStatusTip('Number of members in each generation')
self.lepop.hide()
self.len_r = QLineEdit()
self.len_r.setText(str(globals.algo_data["n_r"]))
self.len_r.setStatusTip('Number of members in a mating pool')
self.len_r.hide()
self.len_e = QLineEdit()
self.len_e.setText(str(globals.algo_data["n_e"]))
self.len_e.setStatusTip('Number of elite children')
self.len_e.hide()
self.lec_f = QLineEdit()
self.lec_f.setText(str(globals.algo_data["c_f"]))
self.lec_f.setStatusTip('Proportion of children spawned through crossover')
self.lec_f.hide()
label_algo = QLabel('Algorithm')
#label_algo.setMinimumWidth(150)
self.combo_algo = QComboBox()
self.combo_algo.addItem("Newton-Raphson")
self.combo_algo.addItem("Levenberg-Marquardt")
self.combo_algo.addItem("Damped Newton-Raphson")
self.combo_algo.addItem("Genetic Algorithm")
self.combo_algo.addItem("Hybrid GA-NR")
self.combo_algo.addItem("Hybrid GA-LM")
self.combo_algo.addItem("Hybrid GA-DNR")
calc_button = QPushButton("Calculate")
calc_button.setStatusTip('Estimate equivalent circuit parameters')
self.plot_button = QPushButton("Plot")
self.plot_button.setDisabled(1)
self.plot_button.setStatusTip('Plot torque-speed and current-speed curves')
####################
# Algorithm results
####################
header4 = QLabel('Results')
#header4.setMinimumWidth(150)
header4.setMinimumHeight(40)
header4.setFont(heading_font)
label13 = QLabel('R_s')
#label13.setFixedWidth(50)
self.leRs = QLineEdit()
self.leRs.setStatusTip('Stator resistance (pu)')
label14 = QLabel('X_s')
#label14.setMinimumWidth(150)
self.leXs = QLineEdit()
self.leXs.setStatusTip('Stator reactance (pu)')
label15 = QLabel('X_m')
#label15.setMinimumWidth(150)
self.leXm = QLineEdit()
self.leXm.setStatusTip('Magnetising resistance (pu)')
label16 = QLabel('X_r1')
#label16.setMinimumWidth(150)
self.leXr1 = QLineEdit()
self.leXr1.setStatusTip('Inner cage rotor reactance (pu)')
label17 = QLabel('R_r1')
#label17.setMinimumWidth(150)
self.leRr1 = QLineEdit()
self.leRr1.setStatusTip('Inner cage rotor resistance (pu)')
self.label18 = QLabel('X_r2')
#label18.setMinimumWidth(150)
self.leXr2 = QLineEdit()
self.leXr2.setStatusTip('Outer cage rotor reactance (pu)')
self.label19 = QLabel('R_r2')
#label19.setMinimumWidth(150)
self.leRr2 = QLineEdit()
self.leRr2.setStatusTip('Outer cage rotor resistance (pu)')
label20 = QLabel('R_c')
#label20.setMinimumWidth(150)
self.leRc = QLineEdit()
self.leRc.setStatusTip('Core loss resistance (pu)')
label21 = QLabel('Converged?')
#label21.setMinimumWidth(150)
self.leConv = QLineEdit()
self.leConv.setStatusTip('Did algorithm converge?')
label22 = QLabel('Squared Error')
#label22.setMinimumWidth(150)
self.leErr = QLineEdit()
self.leErr.setStatusTip('Squared error of estimate')
label23 = QLabel('Iterations')
#label23.setMinimumWidth(150)
self.leIter = QLineEdit()
self.leIter.setStatusTip('Number of iterations / generations')
##############
# Grid layout
##############
grid = QGridLayout()
# Motor details
i = 0
grid.addWidget(header1, i, 0)
grid.addWidget(label1, i+1, 0)
grid.addWidget(self.le1, i+1, 1, 1, 5)
grid.addWidget(label2, i+2, 0)
grid.addWidget(self.le2, i+2, 1)
grid.addWidget(label2a, i+2, 2)
grid.addWidget(label3, i+3, 0)
grid.addWidget(self.le3, i+3, 1)
grid.addWidget(label3a, i+3, 2)
grid.addWidget(label4, i+4, 0)
grid.addWidget(self.le4, i+4, 1)
grid.addWidget(label4a, i+4, 2)
grid.addWidget(label5, i+5, 0)
grid.addWidget(self.le5, i+5, 1)
grid.addWidget(label5a, i+5, 2)
grid.addWidget(label6, i+3, 4)
grid.addWidget(self.le6, i+3, 5)
grid.addWidget(label6a, i+3, 6)
grid.addWidget(label7, i+4, 4)
grid.addWidget(self.le7, i+4, 5)
grid.addWidget(label7a, i+4, 6)
grid.addWidget(label8, i+5, 4)
grid.addWidget(self.le8, i+5, 5)
grid.addWidget(label8a, i+5, 6)
grid.addWidget(label_rp, i+6, 0)
grid.addWidget(self.lex9, i+6, 1)
grid.addWidget(labelex9, i+6, 2)
grid.addWidget(label_ri, i+7, 0)
grid.addWidget(self.lex10, i+7, 1)
grid.addWidget(labelex10, i+7, 2)
grid.addWidget(label_rv, i+8, 0)
grid.addWidget(self.lex11, i+8, 1)
grid.addWidget(labelex11, i+8, 2)
# Model
i = 9
#grid.addWidget(header2, i, 0)
grid.addWidget(label_model, i+1, 0)
grid.addWidget(self.combo_model, i+1, 1)
grid.addWidget(self.img1, i+1, 3, i-7, 6)
# Algorithm settings
i = 12
grid.addWidget(header3, i, 0)
grid.addWidget(label_algo, i+1, 0)
grid.addWidget(self.combo_algo, i+1, 1)
grid.addWidget(label9, i+2, 0)
grid.addWidget(self.le9, i+2, 1)
grid.addWidget(label10, i+3, 0)
grid.addWidget(self.le10, i+3, 1)
grid.addWidget(self.label11, i+2, 3)
grid.addWidget(self.le11, i+2, 4)
grid.addWidget(self.label12, i+3, 3)
grid.addWidget(self.le12, i+3, 4)
# Genetic algorithm parameters
grid.addWidget(self.labeln_gen, i+2, 3)
grid.addWidget(self.len_gen, i+2, 4)
grid.addWidget(self.labelpop, i+3, 3)
grid.addWidget(self.lepop, i+3, 4)
grid.addWidget(self.labeln_r, i+4, 3)
grid.addWidget(self.len_r, i+4, 4)
grid.addWidget(self.labeln_e, i+2, 5)
grid.addWidget(self.len_e, i+2, 6)
grid.addWidget(self.labelc_f, i+3, 5)
grid.addWidget(self.lec_f, i+3, 6)
grid.addWidget(calc_button, i+4, 5)
grid.addWidget(self.plot_button, i+4, 6)
# Algorithm results
i = 17
grid.addWidget(header4, i, 0)
grid.addWidget(label13, i+1, 0)
grid.addWidget(self.leRs, i+1, 1)
grid.addWidget(label14, i+2, 0)
grid.addWidget(self.leXs, i+2, 1)
grid.addWidget(label15, i+3, 0)
grid.addWidget(self.leXm, i+3, 1)
grid.addWidget(label20, i+4, 0)
grid.addWidget(self.leRc, i+4, 1)
grid.addWidget(label16, i+1, 3)
grid.addWidget(self.leXr1, i+1, 4)
grid.addWidget(label17, i+2, 3)
grid.addWidget(self.leRr1, i+2, 4)
grid.addWidget(self.label18, i+3, 3)
grid.addWidget(self.leXr2, i+3, 4)
grid.addWidget(self.label19, i+4, 3)
grid.addWidget(self.leRr2, i+4, 4)
grid.addWidget(label21, i+1, 5)
grid.addWidget(self.leConv, i+1, 6)
grid.addWidget(label22, i+2, 5)
grid.addWidget(self.leErr, i+2, 6)
grid.addWidget(label23, i+3, 5)
grid.addWidget(self.leIter, i+3, 6)
grid.setAlignment(Qt.AlignTop)
main_screen = QWidget()
main_screen.setLayout(grid)
main_screen.setStatusTip('Ready')
self.setCentralWidget(main_screen)
# Event handlers
calc_button.clicked.connect(self.calculate)
self.plot_button.clicked.connect(self.plot_curves)
self.le1.editingFinished.connect(self.update_data)
self.le2.editingFinished.connect(self.update_data)
self.le3.editingFinished.connect(self.update_data)
self.le4.editingFinished.connect(self.update_data)
self.le5.editingFinished.connect(self.update_data)
self.le6.editingFinished.connect(self.update_data)
self.le7.editingFinished.connect(self.update_data)
self.le8.editingFinished.connect(self.update_data)
self.le9.editingFinished.connect(self.update_data)
self.le10.editingFinished.connect(self.update_data)
self.le11.editingFinished.connect(self.update_data)
self.le12.editingFinished.connect(self.update_data)
self.len_gen.editingFinished.connect(self.update_data)
self.lepop.editingFinished.connect(self.update_data)
self.len_r.editingFinished.connect(self.update_data)
self.len_e.editingFinished.connect(self.update_data)
self.lec_f.editingFinished.connect(self.update_data)
##########################
#TO DO - connects for combo boxes - combo_model and combo_algo (what signal to use?)
##########################
self.combo_algo.currentIndexChanged.connect(self.update_algo)
self.combo_model.currentIndexChanged.connect(self.update_model)
self.statusBar().showMessage('Ready')
# Calculate parameter estimates
def calculate(self):
self.statusBar().showMessage('Calculating...')
sf = (globals.motor_data["sync_speed"] - globals.motor_data["rated_speed"]) / globals.motor_data["sync_speed"]
if self.combo_model.currentIndex() == 0:
# Single cage
p = [sf, globals.motor_data["rated_eff"], globals.motor_data["rated_pf"], globals.motor_data["T_b"]]
[z, iter, err, conv] = nr_solver_sc(p, 0, globals.algo_data["k_x"], globals.algo_data["k_r"], globals.algo_data["max_iter"], globals.algo_data["conv_err"])
else:
# Double cage
p = [sf, globals.motor_data["rated_eff"], globals.motor_data["rated_pf"], globals.motor_data["T_b"], globals.motor_data["T_lr"], globals.motor_data["I_lr"] ]
if self.combo_algo.currentText() == "Newton-Raphson":
[z, iter, err, conv] = nr_solver(p, 0, globals.algo_data["k_x"], globals.algo_data["k_r"], globals.algo_data["max_iter"], globals.algo_data["conv_err"])
if self.combo_algo.currentText() == "Levenberg-Marquardt":
[z, iter, err, conv] = lm_solver(p, 0, globals.algo_data["k_x"], globals.algo_data["k_r"], 1e-7, 5.0, globals.algo_data["max_iter"], globals.algo_data["conv_err"])
if self.combo_algo.currentText() == "Damped Newton-Raphson":
[z, iter, err, conv] = dnr_solver(p, 0, globals.algo_data["k_x"], globals.algo_data["k_r"], 1e-7, globals.algo_data["max_iter"], globals.algo_data["conv_err"])
if self.combo_algo.currentText() == "Genetic Algorithm":
[z, iter, err, conv] = ga_solver(self, p, globals.algo_data["pop"], globals.algo_data["n_r"], globals.algo_data["n_e"], globals.algo_data["c_f"], globals.algo_data["n_gen"], globals.algo_data["conv_err"])
if self.combo_algo.currentText() == "Hybrid GA-NR":
[z, iter, err, conv] = hy_solver(self, "NR", p, globals.algo_data["pop"], globals.algo_data["n_r"], globals.algo_data["n_e"], globals.algo_data["c_f"], globals.algo_data["n_gen"], globals.algo_data["conv_err"])
if self.combo_algo.currentText() == "Hybrid GA-LM":
[z, iter, err, conv] = hy_solver(self, "LM", p, globals.algo_data["pop"], globals.algo_data["n_r"], globals.algo_data["n_e"], globals.algo_data["c_f"], globals.algo_data["n_gen"], globals.algo_data["conv_err"])
if self.combo_algo.currentText() == "Hybrid GA-DNR":
[z, iter, err, conv] = hy_solver(self, "DNR", p, globals.algo_data["pop"], globals.algo_data["n_r"], globals.algo_data["n_e"], globals.algo_data["c_f"], globals.algo_data["n_gen"], globals.algo_data["conv_err"])
self.leRs.setText(str(np.round(z[0],5)))
self.leXs.setText(str(np.round(z[1],5)))
self.leXm.setText(str(np.round(z[2],5)))
self.leRr1.setText(str(np.round(z[3],5)))
if self.combo_model.currentIndex() == 1:
self.leXr1.setText(str(np.round(z[4],5)))
self.leRr2.setText(str(np.round(z[5],5)))
self.leXr2.setText(str(np.round(z[6],5)))
self.leRc.setText(str(np.round(z[7],5)))
else:
self.leRc.setText(str(np.round(z[4],5)))
self.leXr1.setText(str(np.round(z[5],5)))
if conv == 1:
self.leConv.setText("Yes")
else:
QMessageBox.warning(self, 'Warning', "Algorithm did not converge.", QMessageBox.Ok)
self.leConv.setText("No")
self.leErr.setText(str(np.round(err,9)))
self.leIter.setText(str(iter))
# Only enable the plot button if the squared error is within the bounds of reason
if err < 1:
self.plot_button.setEnabled(1)
else:
self.plot_button.setDisabled(1)
self.statusBar().showMessage('Ready')
# Plot torque-speed and current-speed curves
def plot_curves(self):
sf = (globals.motor_data["sync_speed"] - globals.motor_data["rated_speed"]) / globals.motor_data["sync_speed"]
if self.combo_model.currentIndex() == 0:
# Single cage
x = [float(self.leRs.text()), float(self.leXs.text()) , float(self.leXm.text()), float(self.leRr1.text()), float(self.leRc.text()), float(self.leXr1.text())]
else:
# Double cage
x = [float(self.leRs.text()), float(self.leXs.text()) , float(self.leXm.text()), float(self.leRr1.text()), float(self.leXr1.text()), float(self.leRr2.text()), float(self.leXr2.text()), float(self.leRc.text())]
# Rated per-unit torque
T_rtd = globals.motor_data["rated_eff"] * globals.motor_data["rated_pf"] / (1 - sf)
Tm = np.zeros(1001)
Im = np.zeros(1001)
speed = np.zeros(1001)
speed[1000] = globals.motor_data["sync_speed"]
for n in range(0,1000):
speed[n] = float(n) / 1000 * globals.motor_data["sync_speed"]
i = 1 - float(n) / 1000
if self.combo_model.currentIndex() == 0:
# Single cage
[Ti, Ii] = get_torque_sc(i,x)
else:
# Double cage
[Ti, Ii] = get_torque(i,x)
Tm[n] = Ti / T_rtd # Convert torque to T/Tn value
Im[n] = np.abs(Ii)
# Plot torque-speed and current-speed curves
if plt.fignum_exists(1):
# Do nothing
QMessageBox.warning(self, 'Warning', "A plot is already open. Please close to create a new plot.", QMessageBox.Ok)
else:
plt.figure(1, facecolor='white')
plt.subplot(211)
plt.plot(speed, Tm)
plt.xlim([0, globals.motor_data["sync_speed"]])
plt.xlabel("Speed (rpm)")
plt.ylabel("Torque (T/Tn)")
plt.grid(color = '0.75', linestyle='--', linewidth=1)
plt.subplot(212)
plt.plot(speed, Im, 'r')
plt.xlim([0, globals.motor_data["sync_speed"]])
plt.xlabel("Speed (rpm)")
plt.ylabel("Current (pu)")
plt.grid(color = '0.75', linestyle='--', linewidth=1)
plt.show()
# Update global variables on change in data fields
def update_data(self):
try:
globals.motor_data["description"] = str(self.le1.text())
globals.motor_data["sync_speed"] = float(self.le2.text())
globals.motor_data["rated_speed"] = float(self.le3.text())
globals.motor_data["rated_pf"] = float(self.le4.text())
globals.motor_data["rated_eff"] = float(self.le5.text())
globals.motor_data["T_b"] = float(self.le6.text())
globals.motor_data["T_lr" ] = float(self.le7.text())
globals.motor_data["I_lr"] = float(self.le8.text())
globals.algo_data["max_iter"] = int(self.le9.text())
globals.algo_data["conv_err"] = float(self.le10.text())
globals.algo_data["k_r"] = float(self.le11.text())
globals.algo_data["k_x"] = float(self.le12.text())
globals.algo_data["n_gen"] = int(self.len_gen.text())
globals.algo_data["pop"] = int(self.lepop.text())
globals.algo_data["n_r"] = int(self.len_r.text())
globals.algo_data["n_e"] = int(self.len_e.text())
globals.algo_data["c_f"] = float(self.lec_f.text())
except Exception as err:
print(err)
# Update data in the main window
def update_window(self):
self.le1.setText(str(globals.motor_data["description"]))
self.le2.setText(str(globals.motor_data["sync_speed"]))
self.le3.setText(str(globals.motor_data["rated_speed"]))
self.le4.setText(str(globals.motor_data["rated_pf"]))
self.le5.setText(str(globals.motor_data["rated_eff"]))
self.le6.setText(str(globals.motor_data["T_b"]))
self.le7.setText(str(globals.motor_data["T_lr"]))
self.le8.setText(str(globals.motor_data["I_lr"]))
self.le9.setText(str(globals.algo_data["max_iter"]))
self.le10.setText(str(globals.algo_data["conv_err"]))
self.le11.setText(str(globals.algo_data["k_r"]))
self.le12.setText(str(globals.algo_data["k_x"]))
self.len_gen.setText(str(globals.algo_data["n_gen"]))
self.lepop.setText(str(globals.algo_data["pop"]))
self.len_r.setText(str(globals.algo_data["n_r"]))
self.len_e.setText(str(globals.algo_data["n_e"]))
self.lec_f.setText(str(globals.algo_data["c_f"]))
# Update the screen if the algorithm changes
def update_algo(self):
if (self.combo_algo.currentText() == "Genetic Algorithm") or (self.combo_algo.currentText() == "Hybrid GA-LM") or (self.combo_algo.currentText() == "Hybrid GA-NR") or (self.combo_algo.currentText() == "Hybrid GA-DNR"):
self.label11.setVisible(0)
self.le11.hide()
self.label12.setVisible(0)
self.le12.hide()
self.labeln_gen.setVisible(1)
self.labelpop.setVisible(1)
self.labeln_r.setVisible(1)
self.labeln_e.setVisible(1)
self.labelc_f.setVisible(1)
self.len_gen.show()
self.lepop.show()
self.len_r.show()
self.len_e.show()
self.lec_f.show()
else:
self.label11.setVisible(1)
self.le11.show()
self.label12.setVisible(1)
self.le12.show()
self.labeln_gen.setVisible(0)
self.labelpop.setVisible(0)
self.labeln_r.setVisible(0)
self.labeln_e.setVisible(0)
self.labelc_f.setVisible(0)
self.len_gen.hide()
self.lepop.hide()
self.len_r.hide()
self.len_e.hide()
self.lec_f.hide()
# Update if model combo box changed
def update_model(self):
if self.combo_model.currentIndex() == 0:
# Single cage
self.img1.setPixmap(QPixmap('images\single_cage.png'))
self.combo_algo.setCurrentIndex(0)
self.combo_algo.clear()
self.combo_algo.addItem("Newton-Raphson")
self.label18.setVisible(0)
self.label19.setVisible(0)
self.leXr2.hide()
self.leRr2.hide()
else:
# Double cage
self.img1.setPixmap(QPixmap('images\dbl_cage.png'))
self.combo_algo.addItem("Levenberg-Marquardt")
self.combo_algo.addItem("Damped Newton-Raphson")
self.combo_algo.addItem("Genetic Algorithm")
self.combo_algo.addItem("Hybrid GA-NR")
self.combo_algo.addItem("Hybrid GA-LM")
self.combo_algo.addItem("Hybrid GA-DNR")
self.label18.setVisible(1)
self.label19.setVisible(1)
self.leXr2.show()
self.leRr2.show()
# Open file and load motor data
def load_action(self):
# Open file dialog box
filename = QFileDialog.getOpenFileName(self, "Open Moto File", "library/", "Moto files (*.mto)")
if filename[0]:
saveload.load_file(filename[0])
self.update_window()
# Save motor data to file
def save_action(self):
# Open save file dialog box
filename = QFileDialog.getSaveFileName(self, "Save Moto File", "library/", "Moto files (*.mto)")
if filename:
saveload.save_file(filename)
# Launch user manual
def user_manual(self):
os.system("start docs/moto_user_manual.pdf")
# About dialog box
def about_dialog(self):
QMessageBox.about(self, "About Moto",
"""<b>Moto</b> is a parameter estimation tool that can be used to determine the equivalent circuit parameters of induction machines. The tool is intended for use in dynamic time-domain simulations such as stability and motor starting studies.
<p>
Version: <b>v0.2<b><P>
<p>
Website: <a href="http://www.sigmapower.com.au/moto.html">www.sigmapower.com.au/moto.html</a>
<p> </p>
<p><img src="images/Sigma_Power.png"></p>
<p>© 2014 Sigma Power Engineering Pty Ltd</p>
<p>All rights reserved.</p>
""")
# Centre application window on screen
def centre(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
class Compass(COMCUPluginBase):
def __init__(self, *args):
super().__init__(BrickletCompass, *args)
self.compass = self.device
self.cbe_mfd = CallbackEmulator(self.compass.get_magnetic_flux_density, None, self.cb_mfd, self.increase_error_count)
self.calibration = None
self.compass_widget = CompassWidget()
self.current_mfd_x = CurveValueWrapper() # int, mG
self.current_mfd_y = CurveValueWrapper() # int, mG
self.current_mfd_z = CurveValueWrapper() # int, mG
self.heading_label = HeadingLabel()
self.inclination_label = InclinationLabel()
self.label_widget = QWidget()
self.label_layout = QVBoxLayout()
self.label_layout.addWidget(self.heading_label)
self.label_layout.addWidget(self.inclination_label)
self.label_widget.setLayout(self.label_layout)
plots = [('X', Qt.red, self.current_mfd_x, '{0} mG'.format),
('Y', Qt.darkGreen, self.current_mfd_y, '{0} mG'.format),
('Z', Qt.blue, self.current_mfd_z, '{0} mG'.format)]
self.plot_widget = PlotWidget('Magnetic Flux Density [mG]', plots, extra_key_widgets=[self.compass_widget, self.label_widget],
update_interval=0.1, y_resolution=1)
self.dr_label = QLabel('Data Rate:')
self.dr_combo = QComboBox()
self.dr_combo.addItem("100 Hz")
self.dr_combo.addItem("200 Hz")
self.dr_combo.addItem("400 Hz")
self.dr_combo.addItem("600 Hz")
self.dr_combo.currentIndexChanged.connect(self.new_config)
self.button_calibration = QPushButton('Calibrate')
self.button_calibration.clicked.connect(self.calibration_clicked)
hlayout = QHBoxLayout()
hlayout.addStretch()
hlayout.addWidget(self.dr_label)
hlayout.addWidget(self.dr_combo)
hlayout.addStretch()
hlayout.addWidget(self.button_calibration)
hlayout.addStretch()
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 calibration_clicked(self):
if self.calibration == None:
self.calibration = Calibration(self)
self.button_calibration.setEnabled(False)
self.calibration.show()
def new_config(self):
dr = self.dr_combo.currentIndex()
self.compass.set_configuration(dr, True)
def cb_mfd(self, data):
x, y, z = data
inclination = int(round(180/math.pi * math.atan2(z, math.hypot(y, x)), 0))
heading = int(round(math.atan2(y, x)*180/math.pi, 0))
if heading < 0:
heading += 360
self.current_mfd_x.value = int(round(x / 10.0, 0))
self.current_mfd_y.value = int(round(y / 10.0, 0))
self.current_mfd_z.value = int(round(z / 10.0, 0))
self.heading_label.setText(heading)
self.compass_widget.set_angle(heading)
self.inclination_label.setText(inclination)
def get_configuration_async(self, conf):
self.dr_combo.setCurrentIndex(conf.data_rate)
def start(self):
async_call(self.compass.get_configuration, None, self.get_configuration_async, self.increase_error_count)
self.cbe_mfd.set_period(50)
self.plot_widget.stop = False
def stop(self):
self.cbe_mfd.set_period(0)
self.plot_widget.stop = True
def destroy(self):
pass
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickletCompass.DEVICE_IDENTIFIER
class Photon_Counter(QMainWindow):
def __init__(self):
super().__init__()
self.dossier = './'
##Creation of the graphical interface##
self.setWindowTitle("Data Fit")
self.main = QWidget()
self.setCentralWidget(self.main)
layout = QHBoxLayout()
Vbox_gauche = QVBoxLayout()
Vbox = QVBoxLayout()
layout.addLayout(Vbox_gauche)
layout.addLayout(Vbox)
self.main.setLayout(layout)
#Buttons on the left
self.open = QPushButton('Open')
self.choseline = QComboBox()
self.choseline.setEnabled(False)
self.fitMenu = QComboBox()
self.fitMenu.setEnabled(False)
self.reset = QPushButton('Clear File')
Vbox_gauche.addWidget(self.open)
Vbox_gauche.addWidget(self.choseline)
Vbox_gauche.addWidget(self.fitMenu)
Vbox_gauche.addStretch(1)
Vbox_gauche.addWidget(self.reset)
#Plot in the middle
self.canvas = FigureCanvas(Figure(figsize=(30, 10)))
self.ax = self.canvas.figure.subplots()
Vbox.addStretch(1)
Vbox.addWidget(self.canvas)
self.addToolBar(Qt.BottomToolBarArea,
NavigationToolbar(self.canvas, self))
#Define the widgets actions
self.open.clicked.connect(self.get_data)
self.choseline.activated.connect(self.plot_data)
self.fitMenu.activated.connect(self.fit_data)
self.reset.clicked.connect(self.clean_plot)
def get_data(self):
fname, filters = QFileDialog.getOpenFileName(self, "Chose a data file",
self.dossier,
"Data files (*.txt)")
if fname != "":
self.dossier = os.path.dirname(fname)
self.data = []
with open(fname, 'r') as f:
for textLine in f:
textLine = textLine.split(
) #Assumes tab/space as separator; else add the separator here
numLine = []
for elem in textLine:
try:
numLine += [
float(elem)
] #Instructions to skip lines with text
except:
break
if numLine != []:
self.data += [numLine]
self.numLine = int(
len(self.data[0]) / 2
) #Data files must have an even number of columns, one for x and one for y
self.choseline.clear()
self.choseline.addItem('<none')
for i in range(self.numLine):
self.choseline.addItem('Line %i' % (i + 1))
self.choseline.setEnabled(True)
def plot_data(self):
index = self.choseline.currentIndex() - 1
if index >= 0:
x = []
y = []
for line in self.data:
x += [line[index * 2]]
y += [line[index * 2 + 1]]
self.currentLine = np.array([x, y])
self.ax.plot(x, y)
self.ax.autoscale()
self.ax.figure.canvas.draw()
self.fitMenu.clear()
self.fitMenu.addItem('<none')
self.cf = curveFitting(x, y)
self.listFits = [
func for func in dir(self.cf)
if (callable(getattr(self.cf, func)) and func[0] != "_")
]
for func in self.listFits:
self.fitMenu.addItem(func)
self.fitMenu.setEnabled(True)
def fit_data(self):
fitName = self.fitMenu.currentText()
getattr(self.cf, fitName)()
self.ax.plot(self.cf.x, self.cf.fit, label=self.cf.label)
self.ax.legend()
self.ax.figure.canvas.draw()
def clean_plot(self):
self.ax.clear()
self.ax.figure.canvas.draw()
class ErgebnissListe(QWidget):
template = "<tr><td>Eintrag von </td><td>{: >20}</td><td>in der Disziplin {:<15} </td><td>{}erfolgreich {}</td></tr>"
def __init__(self,parent=None):
super(ErgebnissListe, self).__init__(parent)
self.auswahlAlter = QComboBox()
self.auswahlAlter.addItem("Bitte auswählen")
for i in range(3,18):
self.auswahlAlter.addItem("{} Jahre / Jahrgang {}".format(i, date.today().year-i))
self.auswahlAlter.activated.connect(self.auswahlKlasse)
self.auswahlAlter.activated.connect(self.waehleDisziplinen)
self.auswahlGeschlecht = QComboBox()
self.auswahlGeschlecht.addItem("Bitte auswählen")
self.auswahlGeschlecht.addItem("Männlich")
self.auswahlGeschlecht.addItem("Weiblich")
self.auswahlGeschlecht.activated.connect(self.auswahlKlasse)
self.auswahlGeschlecht.activated.connect(self.waehleDisziplinen)
self.auswahlDisziplin = QComboBox()
self.auswahlDisziplin.addItem("Bitte auswählen")
for i in getDisziplin(10):
self.auswahlDisziplin.addItem(i)
self.auswahlDisziplin.activated.connect(self.auswahlKlasse)
self.mainLayout = QGridLayout()
self.mainLayout.addWidget(QLabel("Alter:"), 0, 0)
self.mainLayout.addWidget(self.auswahlAlter, 0, 1, 1, 3)
self.mainLayout.addWidget(QLabel("Geschlecht:"), 1, 0)
self.mainLayout.addWidget(self.auswahlGeschlecht, 1, 1, 1, 3)
self.mainLayout.addWidget(QLabel("Disziplin:"), 2, 0)
self.mainLayout.addWidget(self.auswahlDisziplin, 2, 1, 1, 3)
self._speichern = QPushButton("Speichern")
self._speichern.clicked.connect(self.speichern)
self.setLayout(self.mainLayout)
self._sportler = []
self.update()
def waehleDisziplinen(self):
self.auswahlDisziplin.clear()
self.auswahlDisziplin.addItem("Bitte auswählen")
for i in getDisziplin(self.auswahlAlter.currentIndex()+2):
self.auswahlDisziplin.addItem(i)
def auswahlKlasse(self):
if self.auswahlAlter.currentIndex() == 0:
return False
elif self.auswahlGeschlecht.currentIndex() == 0:
return False
elif self.auswahlDisziplin.currentIndex() == 0:
return False
self.clearAuswahl()
disziplin = self.auswahlDisziplin.currentIndex()-1
if self.auswahlDisziplin.currentText() is "-":
return
for sportler in QueryTool().queryAndFetch("SELECT ID, Name, Vorname FROM LG_NGD WHERE WieAlt = ? AND Geschlecht = ?",
self.auswahlAlter.currentIndex()+2,
bool(self.auswahlGeschlecht.currentIndex()-1)):
self._sportler += [sportler[0]]
name = "{} {}".format(sportler[2],sportler[1])
#UID, Name
for werte in reversed(QueryTool().queryAndFetch("SELECT Wert1, Wert2, Wert3 FROM LG_NGD_Ergebnisse WHERE UID = ? "
"AND Typ = ? UNION SELECT 0, 0, 0",
sportler[0],
disziplin)):
row = self.mainLayout.rowCount()
self.mainLayout.addWidget(QLabel(name), row, 0)
for i in range(0,felderzahl[disziplin]):
el = QDoubleSpinBox()
el.setMaximum(99999)
el.setValue(werte[i])
el.setSuffix(" "+einheiten[disziplin])
el.setSingleStep(0.01)
self.mainLayout.addWidget(el, row, i+1, 1, 3/felderzahl[disziplin])
break
self._speichern = QPushButton("Speichern")
self._speichern.clicked.connect(self.speichern)
self.mainLayout.addWidget(self._speichern, self.mainLayout.rowCount(), 0, 1, 4)
def speichern(self):
row = self.mainLayout.rowCount()-len(self._sportler)-1
disziplin = self.auswahlDisziplin.currentIndex()-1
ausgabe = "<table>"
for UID in self._sportler:
werte = ["0","0","0"]
for col in range(1, 1+felderzahl[disziplin]):
item = self.mainLayout.itemAtPosition(row, col)
text = "0"
try:
if type(item.widget()) is not type(QDoubleSpinBox()):
raise TypeError("No LineEdit")
text = item.widget().value()
except TypeError:
text = "0"
except AttributeError:
text = "0"
werte[col-1]=text
data = QueryTool().queryAndFetch("SELECT * FROM LG_NGD_Ergebnisse WHERE UID = ? AND Typ = ?",UID,disziplin)
ergebnisse = None
typ = None
if len(data) is not 0:
ergebniss = QueryTool().update("LG_NGD_Ergebnisse", data[0][0], Wert1=werte[0], Wert2=werte[1], Wert3=werte[2])
typ = "aktualisiert"
else:
ergebniss = QueryTool().insert("LG_NGD_Ergebnisse", UID=UID, Typ=disziplin, Wert1=werte[0], Wert2=werte[1], Wert3=werte[2])
typ = "eingetragen"
username = self.mainLayout.itemAtPosition(row, 0)
if type(username.widget()) is not type(QLabel()):
username = ""
else:
username = username.widget().text()
ausgabe += self.template.format(username, list(getDisziplin(self.auswahlAlter.currentIndex()+2))[disziplin],
"nicht " if ergebniss is None else "", typ)
row += 1
ausgabe += "</table>"
QMessageBox.information(self, "Eintragungsstatus", ausgabe)
def clearAuswahl(self):
for w in self.iterWidgets(True):
w[0].setParent(None)
self._sportler=[]
def iterWidgets(self,allWidgets = False)->QWidget:
for row in range(3, self.mainLayout.rowCount()-(1 if not allWidgets else 0)):
for col in range(self.mainLayout.columnCount()):
item = self.mainLayout.itemAtPosition(row, col)
if item is not None and item.widget() is not None:
yield (item.widget(), row, col)
else:
break
def update(self):
if not self.auswahlKlasse():
return
class UVLightV2(COMCUPluginBase):
def __init__(self, *args):
super().__init__(BrickletUVLightV2, *args)
self.uv_light = self.device
self.cbe_uva = CallbackEmulator(self, self.uv_light.get_uva, None,
self.cb_uva, self.increase_error_count)
self.cbe_uvb = CallbackEmulator(self, self.uv_light.get_uvb, None,
self.cb_uvb, self.increase_error_count)
self.cbe_uvi = CallbackEmulator(self, self.uv_light.get_uvi, None,
self.cb_uvi, self.increase_error_count)
self.index_label = IndexLabel(' UVI: ? ')
self.index_label.setText('0.0')
self.current_uva = CurveValueWrapper()
self.current_uvb = CurveValueWrapper()
plots = [('UVA', Qt.red, self.current_uva, '{} mW/m²'.format),
('UVB', Qt.darkGreen, self.current_uvb, '{} mW/m²'.format)]
self.plot_widget = PlotWidget('UV [mW/m²]',
plots,
extra_key_widgets=[self.index_label],
y_resolution=0.1)
self.time_label = QLabel('Integration Time:')
self.time_combo = QComboBox()
self.time_combo.addItem("50 ms",
BrickletUVLightV2.INTEGRATION_TIME_50MS)
self.time_combo.addItem("100 ms",
BrickletUVLightV2.INTEGRATION_TIME_100MS)
self.time_combo.addItem("200 ms",
BrickletUVLightV2.INTEGRATION_TIME_200MS)
self.time_combo.addItem("400 ms",
BrickletUVLightV2.INTEGRATION_TIME_400MS)
self.time_combo.addItem("800 ms",
BrickletUVLightV2.INTEGRATION_TIME_800MS)
self.time_combo.currentIndexChanged.connect(self.new_config)
self.saturation_label = QLabel(
'Sensor is saturated, choose a shorter integration time!')
self.saturation_label.setStyleSheet('QLabel { color : red }')
self.saturation_label.hide()
hlayout = QHBoxLayout()
hlayout.addWidget(self.time_label)
hlayout.addWidget(self.time_combo)
hlayout.addStretch()
hlayout.addWidget(self.saturation_label)
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 start(self):
async_call(self.uv_light.get_configuration, None,
self.get_configucation_async, self.increase_error_count)
self.cbe_uva.set_period(100)
self.cbe_uvb.set_period(100)
self.cbe_uvi.set_period(100)
self.plot_widget.stop = False
def stop(self):
self.cbe_uva.set_period(0)
self.cbe_uvb.set_period(0)
self.cbe_uvi.set_period(0)
self.plot_widget.stop = True
def destroy(self):
pass
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickletUVLightV2.DEVICE_IDENTIFIER
def get_configucation_async(self, integration_time):
self.time_combo.setCurrentIndex(
self.time_combo.findData(integration_time))
def new_config(self, value):
try:
self.uv_light.set_configuration(
self.time_combo.itemData(self.time_combo.currentIndex()))
except:
pass
def cb_uva(self, uva):
self.saturation_label.setVisible(uva < 0)
if uva < 0: # saturated
return
self.current_uva.value = uva / 10.0
def cb_uvb(self, uvb):
self.saturation_label.setVisible(uvb < 0)
if uvb < 0: # saturated
return
self.current_uvb.value = uvb / 10.0
def cb_uvi(self, uvi):
self.saturation_label.setVisible(uvi < 0)
if uvi < 0: # saturated
return
uvi = round(uvi / 10.0, 1)
self.index_label.setText(str(uvi))
if uvi < 2.5:
background = 'green'
color = 'white'
elif uvi < 5.5:
background = 'yellow'
color = 'black'
elif uvi < 7.5:
background = 'orange'
color = 'black'
elif uvi < 10.5:
background = 'red'
color = 'white'
else:
background = 'magenta'
color = 'white'
self.index_label.setStyleSheet(
'QLabel {{ background : {0}; color : {1} }}'.format(
background, color))
class SquidGui( QMainWindow ):
defaults = {}
defaults.update(SquidAxon.defaults)
defaults.update(ClampCircuit.defaults)
defaults.update({'runtime': 50.0,
'simdt': 0.01,
'plotdt': 0.1,
'vclamp.holdingV': 0.0,
'vclamp.holdingT': 10.0,
'vclamp.prepulseV': 0.0,
'vclamp.prepulseT': 0.0,
'vclamp.clampV': 50.0,
'vclamp.clampT': 20.0,
'iclamp.baseI': 0.0,
'iclamp.firstI': 0.1,
'iclamp.firstT': 40.0,
'iclamp.firstD': 5.0,
'iclamp.secondI': 0.0,
'iclamp.secondT': 0.0,
'iclamp.secondD': 0.0
})
def __init__(self, *args):
QMainWindow.__init__(self, *args)
self.squid_setup = SquidSetup()
self._plotdt = SquidGui.defaults['plotdt']
self._plot_dict = defaultdict(list)
self.setWindowTitle('Squid Axon simulation')
self.setDockNestingEnabled(True)
self._createRunControl()
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._runControlDock)
self._runControlDock.setFeatures(QDockWidget.AllDockWidgetFeatures)
self._createChannelControl()
self._channelCtrlBox.setWindowTitle('Channel properties')
self._channelControlDock.setFeatures(QDockWidget.AllDockWidgetFeatures)
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._channelControlDock)
self._createElectronicsControl()
self._electronicsDock.setFeatures(QDockWidget.AllDockWidgetFeatures)
self._electronicsDock.setWindowTitle('Electronics')
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._electronicsDock)
self._createPlotWidget()
self.setCentralWidget(self._plotWidget)
self._createStatePlotWidget()
self._createHelpMessage()
self._helpWindow.setVisible(False)
self._statePlotWidget.setWindowFlags(QtCore.Qt.Window)
self._statePlotWidget.setWindowTitle('State plot')
self._initActions()
self._createRunToolBar()
self._createPlotToolBar()
def getFloatInput(self, widget, name):
try:
return float(str(widget.text()))
except ValueError:
QMessageBox.critical(self, 'Invalid input', 'Please enter a valid number for {}'.format(name))
raise
def _createPlotWidget(self):
self._plotWidget = QWidget()
self._plotFigure = Figure()
self._plotCanvas = FigureCanvas(self._plotFigure)
self._plotCanvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self._plotCanvas.updateGeometry()
self._plotCanvas.setParent(self._plotWidget)
self._plotCanvas.mpl_connect('scroll_event', self._onScroll)
self._plotFigure.set_canvas(self._plotCanvas)
# Vm and command voltage go in the same subplot
self._vm_axes = self._plotFigure.add_subplot(2,2,1, title='Membrane potential')
self._vm_axes.set_ylim(-20.0, 120.0)
# Channel conductances go to the same subplot
self._g_axes = self._plotFigure.add_subplot(2,2,2, title='Channel conductance')
self._g_axes.set_ylim(0.0, 0.5)
# Injection current for Vclamp/Iclamp go to the same subplot
self._im_axes = self._plotFigure.add_subplot(2,2,3, title='Injection current')
self._im_axes.set_ylim(-0.5, 0.5)
# Channel currents go to the same subplot
self._i_axes = self._plotFigure.add_subplot(2,2,4, title='Channel current')
self._i_axes.set_ylim(-10, 10)
for axis in self._plotFigure.axes:
axis.set_autoscale_on(False)
layout = QVBoxLayout()
layout.addWidget(self._plotCanvas)
self._plotNavigator = NavigationToolbar(self._plotCanvas, self._plotWidget)
layout.addWidget(self._plotNavigator)
self._plotWidget.setLayout(layout)
def _createStatePlotWidget(self):
self._statePlotWidget = QWidget()
self._statePlotFigure = Figure()
self._statePlotCanvas = FigureCanvas(self._statePlotFigure)
self._statePlotCanvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self._statePlotCanvas.updateGeometry()
self._statePlotCanvas.setParent(self._statePlotWidget)
self._statePlotFigure.set_canvas(self._statePlotCanvas)
self._statePlotFigure.subplots_adjust(hspace=0.5)
self._statePlotAxes = self._statePlotFigure.add_subplot(2,1,1, title='State plot')
self._state_plot, = self._statePlotAxes.plot([], [], label='state')
self._activationParamAxes = self._statePlotFigure.add_subplot(2,1,2, title='H-H activation parameters vs time')
self._activationParamAxes.set_xlabel('Time (ms)')
#for axis in self._plotFigure.axes:
# axis.autoscale(False)
self._stateplot_xvar_label = QLabel('Variable on X-axis')
self._stateplot_xvar_combo = QComboBox()
self._stateplot_xvar_combo.addItems(['V', 'm', 'n', 'h'])
self._stateplot_xvar_combo.setCurrentText('V')
self._stateplot_xvar_combo.setEditable(False)
self._stateplot_xvar_combo.currentIndexChanged[str].connect( self._statePlotXSlot )
self._stateplot_yvar_label = QLabel('Variable on Y-axis')
self._stateplot_yvar_combo = QComboBox()
self._stateplot_yvar_combo.addItems(['V', 'm', 'n', 'h'])
self._stateplot_yvar_combo.setCurrentIndex(2)
self._stateplot_yvar_combo.setEditable(False)
self._stateplot_yvar_combo.currentIndexChanged[str].connect(self._statePlotYSlot)
self._statePlotNavigator = NavigationToolbar(self._statePlotCanvas, self._statePlotWidget)
frame = QFrame()
frame.setFrameStyle(QFrame.StyledPanel + QFrame.Raised)
layout = QHBoxLayout()
layout.addWidget(self._stateplot_xvar_label)
layout.addWidget(self._stateplot_xvar_combo)
layout.addWidget(self._stateplot_yvar_label)
layout.addWidget(self._stateplot_yvar_combo)
frame.setLayout(layout)
self._closeStatePlotAction = QAction('Close', self)
self._closeStatePlotAction.triggered.connect(self._statePlotWidget.close)
self._closeStatePlotButton = QToolButton()
self._closeStatePlotButton.setDefaultAction(self._closeStatePlotAction)
layout = QVBoxLayout()
layout.addWidget(frame)
layout.addWidget(self._statePlotCanvas)
layout.addWidget(self._statePlotNavigator)
layout.addWidget(self._closeStatePlotButton)
self._statePlotWidget.setLayout(layout)
# Setting the close event so that when the help window is
# closed the ``State plot`` button becomes unchecked
self._statePlotWidget.closeEvent = lambda event: self._showStatePlotAction.setChecked(False)
def _createRunControl(self):
self._runControlBox = QGroupBox(self)
self._runControlBox.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self._runTimeLabel = QLabel("Run time (ms)", self._runControlBox)
self._simTimeStepLabel = QLabel("Simulation time step (ms)", self._runControlBox)
self._runTimeEdit = QLineEdit('%g' % (SquidGui.defaults['runtime']), self._runControlBox)
set_default_line_edit_size(self._runTimeEdit)
self._simTimeStepEdit = QLineEdit('%g' % (SquidGui.defaults['simdt']), self._runControlBox)
set_default_line_edit_size(self._simTimeStepEdit)
layout = QGridLayout()
layout.addWidget(self._runTimeLabel, 0, 0)
layout.addWidget(self._runTimeEdit, 0, 1)
layout.addWidget(self._simTimeStepLabel, 1, 0)
layout.addWidget(self._simTimeStepEdit, 1, 1)
layout.setColumnStretch(2, 1.0)
layout.setRowStretch(2, 1.0)
self._runControlBox.setLayout(layout)
self._runControlDock = QDockWidget('Simulation', self)
self._runControlDock.setWidget(self._runControlBox)
def _createChannelControl(self):
self._channelControlDock = QDockWidget('Channels', self)
self._channelCtrlBox = QGroupBox(self)
self._naConductanceToggle = QCheckBox('Block Na+ channel', self._channelCtrlBox)
self._naConductanceToggle.setToolTip('<html>%s</html>' % (tooltip_NaChan))
self._kConductanceToggle = QCheckBox('Block K+ channel', self._channelCtrlBox)
self._kConductanceToggle.setToolTip('<html>%s</html>' % (tooltip_KChan))
self._kOutLabel = QLabel('[K+]out (mM)', self._channelCtrlBox)
self._kOutEdit = QLineEdit('%g' % (self.squid_setup.squid_axon.K_out),
self._channelCtrlBox)
self._kOutLabel.setToolTip('<html>%s</html>' % (tooltip_Nernst))
self._kOutEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst))
set_default_line_edit_size(self._kOutEdit)
self._naOutLabel = QLabel('[Na+]out (mM)', self._channelCtrlBox)
self._naOutEdit = QLineEdit('%g' % (self.squid_setup.squid_axon.Na_out),
self._channelCtrlBox)
self._naOutLabel.setToolTip('<html>%s</html>' % (tooltip_Nernst))
self._naOutEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst))
set_default_line_edit_size(self._naOutEdit)
self._kInLabel = QLabel('[K+]in (mM)', self._channelCtrlBox)
self._kInEdit = QLineEdit('%g' % (self.squid_setup.squid_axon.K_in),
self._channelCtrlBox)
self._kInEdit.setToolTip(tooltip_Nernst)
self._naInLabel = QLabel('[Na+]in (mM)', self._channelCtrlBox)
self._naInEdit = QLineEdit('%g' % (self.squid_setup.squid_axon.Na_in),
self._channelCtrlBox)
self._naInEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst))
self._temperatureLabel = QLabel('Temperature (C)', self._channelCtrlBox)
self._temperatureEdit = QLineEdit('%g' % (self.defaults['temperature'] - CELSIUS_TO_KELVIN),
self._channelCtrlBox)
self._temperatureEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst))
set_default_line_edit_size(self._temperatureEdit)
for child in self._channelCtrlBox.children():
if isinstance(child, QLineEdit):
set_default_line_edit_size(child)
layout = QGridLayout(self._channelCtrlBox)
layout.addWidget(self._naConductanceToggle, 0, 0)
layout.addWidget(self._kConductanceToggle, 1, 0)
layout.addWidget(self._naOutLabel, 2, 0)
layout.addWidget(self._naOutEdit, 2, 1)
layout.addWidget(self._naInLabel, 3, 0)
layout.addWidget(self._naInEdit, 3, 1)
layout.addWidget(self._kOutLabel, 4, 0)
layout.addWidget(self._kOutEdit, 4, 1)
layout.addWidget(self._kInLabel, 5, 0)
layout.addWidget(self._kInEdit, 5, 1)
layout.addWidget(self._temperatureLabel, 6, 0)
layout.addWidget(self._temperatureEdit, 6, 1)
layout.setRowStretch(7, 1.0)
self._channelCtrlBox.setLayout(layout)
self._channelControlDock.setWidget(self._channelCtrlBox)
return self._channelCtrlBox
def __get_stateplot_data(self, name):
data = []
if name == 'V':
data = self.squid_setup.vm_table.vector
elif name == 'm':
data = self.squid_setup.m_table.vector
elif name == 'h':
data = self.squid_setup.h_table.vector
elif name == 'n':
data = self.squid_setup.n_table.vector
else:
raise ValueError('Unrecognized selection: %s' % name )
return numpy.asarray(data)
def _statePlotYSlot(self, selectedItem):
ydata = self.__get_stateplot_data(str(selectedItem))
self._state_plot.set_ydata(ydata)
self._statePlotAxes.set_ylabel(selectedItem)
if str(selectedItem) == 'V':
self._statePlotAxes.set_ylim(-20, 120)
else:
self._statePlotAxes.set_ylim(0, 1)
self._statePlotCanvas.draw()
def _statePlotXSlot(self, selectedItem):
xdata = self.__get_stateplot_data(str(selectedItem))
self._state_plot.set_xdata(xdata)
self._statePlotAxes.set_xlabel(selectedItem)
if str(selectedItem) == 'V':
self._statePlotAxes.set_xlim(-20, 120)
else:
self._statePlotAxes.set_xlim(0, 1)
self._statePlotCanvas.draw()
def _createElectronicsControl(self):
"""Creates a tabbed widget of voltage clamp and current clamp controls"""
self._electronicsTab = QTabWidget(self)
self._electronicsTab.addTab(self._getIClampCtrlBox(), 'Current clamp')
self._electronicsTab.addTab(self._getVClampCtrlBox(), 'Voltage clamp')
self._electronicsDock = QDockWidget(self)
self._electronicsDock.setWidget(self._electronicsTab)
def _getVClampCtrlBox(self):
vClampPanel = QGroupBox(self)
self._vClampCtrlBox = vClampPanel
self._holdingVLabel = QLabel("Holding Voltage (mV)", vClampPanel)
self._holdingVEdit = QLineEdit('%g' % (SquidGui.defaults['vclamp.holdingV']), vClampPanel)
self._holdingTimeLabel = QLabel("Holding Time (ms)", vClampPanel)
self._holdingTimeEdit = QLineEdit('%g' % (SquidGui.defaults['vclamp.holdingT']), vClampPanel)
self._prePulseVLabel = QLabel("Pre-pulse Voltage (mV)", vClampPanel)
self._prePulseVEdit = QLineEdit('%g' % (SquidGui.defaults['vclamp.prepulseV']), vClampPanel)
self._prePulseTimeLabel = QLabel("Pre-pulse Time (ms)", vClampPanel)
self._prePulseTimeEdit = QLineEdit('%g' % (SquidGui.defaults['vclamp.prepulseT']), vClampPanel)
self._clampVLabel = QLabel("Clamp Voltage (mV)", vClampPanel)
self._clampVEdit = QLineEdit('%g' % (SquidGui.defaults['vclamp.clampV']), vClampPanel)
self._clampTimeLabel = QLabel("Clamp Time (ms)", vClampPanel)
self._clampTimeEdit = QLineEdit('%g' % (SquidGui.defaults['vclamp.clampT']), vClampPanel)
for child in vClampPanel.children():
if isinstance(child, QLineEdit):
set_default_line_edit_size(child)
layout = QGridLayout(vClampPanel)
layout.addWidget(self._holdingVLabel, 0, 0)
layout.addWidget(self._holdingVEdit, 0, 1)
layout.addWidget(self._holdingTimeLabel, 1, 0)
layout.addWidget(self._holdingTimeEdit, 1, 1)
layout.addWidget(self._prePulseVLabel, 2, 0)
layout.addWidget(self._prePulseVEdit, 2, 1)
layout.addWidget(self._prePulseTimeLabel,3,0)
layout.addWidget(self._prePulseTimeEdit, 3, 1)
layout.addWidget(self._clampVLabel, 4, 0)
layout.addWidget(self._clampVEdit, 4, 1)
layout.addWidget(self._clampTimeLabel, 5, 0)
layout.addWidget(self._clampTimeEdit, 5, 1)
layout.setRowStretch(6, 1.0)
vClampPanel.setLayout(layout)
return self._vClampCtrlBox
def _getIClampCtrlBox(self):
iClampPanel = QGroupBox(self)
self._iClampCtrlBox = iClampPanel
self._baseCurrentLabel = QLabel("Base Current Level (uA)",iClampPanel)
self._baseCurrentEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.baseI']),iClampPanel)
self._firstPulseLabel = QLabel("First Pulse Current (uA)", iClampPanel)
self._firstPulseEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.firstI']), iClampPanel)
self._firstDelayLabel = QLabel("First Onset Delay (ms)", iClampPanel)
self._firstDelayEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.firstD']),iClampPanel)
self._firstPulseWidthLabel = QLabel("First Pulse Width (ms)", iClampPanel)
self._firstPulseWidthEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.firstT']), iClampPanel)
self._secondPulseLabel = QLabel("Second Pulse Current (uA)", iClampPanel)
self._secondPulseEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.secondI']), iClampPanel)
self._secondDelayLabel = QLabel("Second Onset Delay (ms)", iClampPanel)
self._secondDelayEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.secondD']),iClampPanel)
self._secondPulseWidthLabel = QLabel("Second Pulse Width (ms)", iClampPanel)
self._secondPulseWidthEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.secondT']), iClampPanel)
self._pulseMode = QComboBox(iClampPanel)
self._pulseMode.addItem("Single Pulse")
self._pulseMode.addItem("Pulse Train")
for child in iClampPanel.children():
if isinstance(child, QLineEdit):
set_default_line_edit_size(child)
layout = QGridLayout(iClampPanel)
layout.addWidget(self._baseCurrentLabel, 0, 0)
layout.addWidget(self._baseCurrentEdit, 0, 1)
layout.addWidget(self._firstPulseLabel, 1, 0)
layout.addWidget(self._firstPulseEdit, 1, 1)
layout.addWidget(self._firstDelayLabel, 2, 0)
layout.addWidget(self._firstDelayEdit, 2, 1)
layout.addWidget(self._firstPulseWidthLabel, 3, 0)
layout.addWidget(self._firstPulseWidthEdit, 3, 1)
layout.addWidget(self._secondPulseLabel, 4, 0)
layout.addWidget(self._secondPulseEdit, 4, 1)
layout.addWidget(self._secondDelayLabel, 5, 0)
layout.addWidget(self._secondDelayEdit, 5, 1)
layout.addWidget(self._secondPulseWidthLabel, 6, 0)
layout.addWidget(self._secondPulseWidthEdit, 6, 1)
layout.addWidget(self._pulseMode, 7, 0, 1, 2)
layout.setRowStretch(8, 1.0)
# layout.setSizeConstraint(QLayout.SetFixedSize)
iClampPanel.setLayout(layout)
return self._iClampCtrlBox
def _overlayPlots(self, overlay):
if not overlay:
for axis in (self._plotFigure.axes + self._statePlotFigure.axes):
title = axis.get_title()
axis.clear()
axis.set_title(title)
suffix = ''
else:
suffix = '_%d' % (len(self._plot_dict['vm']))
self._vm_axes.set_xlim(0.0, self._runtime)
self._g_axes.set_xlim(0.0, self._runtime)
self._im_axes.set_xlim(0.0, self._runtime)
self._i_axes.set_xlim(0.0, self._runtime)
self._vm_plot, = self._vm_axes.plot([], [], label='Vm%s'%(suffix))
self._plot_dict['vm'].append(self._vm_plot)
self._command_plot, = self._vm_axes.plot([], [], label='command%s'%(suffix))
self._plot_dict['command'].append(self._command_plot)
# Channel conductances go to the same subplot
self._gna_plot, = self._g_axes.plot([], [], label='Na%s'%(suffix))
self._plot_dict['gna'].append(self._gna_plot)
self._gk_plot, = self._g_axes.plot([], [], label='K%s'%(suffix))
self._plot_dict['gk'].append(self._gk_plot)
# Injection current for Vclamp/Iclamp go to the same subplot
self._iclamp_plot, = self._im_axes.plot([], [], label='Iclamp%s'%(suffix))
self._vclamp_plot, = self._im_axes.plot([], [], label='Vclamp%s'%(suffix))
self._plot_dict['iclamp'].append(self._iclamp_plot)
self._plot_dict['vclamp'].append(self._vclamp_plot)
# Channel currents go to the same subplot
self._ina_plot, = self._i_axes.plot([], [], label='Na%s'%(suffix))
self._plot_dict['ina'].append(self._ina_plot)
self._ik_plot, = self._i_axes.plot([], [], label='K%s'%(suffix))
self._plot_dict['ik'].append(self._ik_plot)
# self._i_axes.legend()
# State plots
self._state_plot, = self._statePlotAxes.plot([], [], label='state%s'%(suffix))
self._plot_dict['state'].append(self._state_plot)
self._m_plot, = self._activationParamAxes.plot([],[], label='m%s'%(suffix))
self._h_plot, = self._activationParamAxes.plot([], [], label='h%s'%(suffix))
self._n_plot, = self._activationParamAxes.plot([], [], label='n%s'%(suffix))
self._plot_dict['m'].append(self._m_plot)
self._plot_dict['h'].append(self._h_plot)
self._plot_dict['n'].append(self._n_plot)
if self._showLegendAction.isChecked():
for axis in (self._plotFigure.axes + self._statePlotFigure.axes):
axis.legend()
def _updateAllPlots(self):
self._updatePlots()
self._updateStatePlot()
def _updatePlots(self):
if len(self.squid_setup.vm_table.vector) <= 0:
return
vm = numpy.asarray(self.squid_setup.vm_table.vector)
cmd = numpy.asarray(self.squid_setup.cmd_table.vector)
ik = numpy.asarray(self.squid_setup.ik_table.vector)
ina = numpy.asarray(self.squid_setup.ina_table.vector)
iclamp = numpy.asarray(self.squid_setup.iclamp_table.vector)
vclamp = numpy.asarray(self.squid_setup.vclamp_table.vector)
gk = numpy.asarray(self.squid_setup.gk_table.vector)
gna = numpy.asarray(self.squid_setup.gna_table.vector)
time_series = numpy.linspace(0, self._plotdt * len(vm), len(vm))
self._vm_plot.set_data(time_series, vm)
time_series = numpy.linspace(0, self._plotdt * len(cmd), len(cmd))
self._command_plot.set_data(time_series, cmd)
time_series = numpy.linspace(0, self._plotdt * len(ik), len(ik))
self._ik_plot.set_data(time_series, ik)
time_series = numpy.linspace(0, self._plotdt * len(ina), len(ina))
self._ina_plot.set_data(time_series, ina)
time_series = numpy.linspace(0, self._plotdt * len(iclamp), len(iclamp))
self._iclamp_plot.set_data(time_series, iclamp)
time_series = numpy.linspace(0, self._plotdt * len(vclamp), len(vclamp))
self._vclamp_plot.set_data(time_series, vclamp)
time_series = numpy.linspace(0, self._plotdt * len(gk), len(gk))
self._gk_plot.set_data(time_series, gk)
time_series = numpy.linspace(0, self._plotdt * len(gna), len(gna))
self._gna_plot.set_data(time_series, gna)
# self._vm_axes.margins(y=0.1)
# self._g_axes.margin(y=0.1)
# self._im_axes.margins(y=0.1)
# self._i_axes.margins(y=0.1)
if self._autoscaleAction.isChecked():
for axis in self._plotFigure.axes:
axis.relim()
axis.margins(0.1, 0.1)
axis.autoscale_view(tight=True)
else:
self._vm_axes.set_ylim(-20.0, 120.0)
self._g_axes.set_ylim(0.0, 0.5)
self._im_axes.set_ylim(-0.5, 0.5)
self._i_axes.set_ylim(-10, 10)
self._vm_axes.set_xlim(0.0, time_series[-1])
self._g_axes.set_xlim(0.0, time_series[-1])
self._im_axes.set_xlim(0.0, time_series[-1])
self._i_axes.set_xlim(0.0, time_series[-1])
self._plotCanvas.draw()
def _updateStatePlot(self):
if len(self.squid_setup.vm_table.vector) <= 0:
return
sx = str(self._stateplot_xvar_combo.currentText())
sy = str(self._stateplot_yvar_combo.currentText())
xdata = self.__get_stateplot_data(sx)
ydata = self.__get_stateplot_data(sy)
minlen = min(len(xdata), len(ydata))
self._state_plot.set_data(xdata[:minlen], ydata[:minlen])
self._statePlotAxes.set_xlabel(sx)
self._statePlotAxes.set_ylabel(sy)
if sx == 'V':
self._statePlotAxes.set_xlim(-20, 120)
else:
self._statePlotAxes.set_xlim(0, 1)
if sy == 'V':
self._statePlotAxes.set_ylim(-20, 120)
else:
self._statePlotAxes.set_ylim(0, 1)
self._activationParamAxes.set_xlim(0, self._runtime)
m = self.__get_stateplot_data('m')
n = self.__get_stateplot_data('n')
h = self.__get_stateplot_data('h')
time_series = numpy.linspace(0, self._plotdt*len(m), len(m))
self._m_plot.set_data(time_series, m)
time_series = numpy.linspace(0, self._plotdt*len(h), len(h))
self._h_plot.set_data(time_series, h)
time_series = numpy.linspace(0, self._plotdt*len(n), len(n))
self._n_plot.set_data(time_series, n)
if self._autoscaleAction.isChecked():
for axis in self._statePlotFigure.axes:
axis.relim()
axis.set_autoscale_on(True)
axis.autoscale_view(True)
self._statePlotCanvas.draw()
def _runSlot(self):
if moose.isRunning():
print('Stopping simulation in progress ...')
moose.stop()
self._runtime = self.getFloatInput(self._runTimeEdit, self._runTimeLabel.text())
self._overlayPlots(self._overlayAction.isChecked())
self._simdt = self.getFloatInput(self._simTimeStepEdit, self._simTimeStepLabel.text())
clampMode = None
singlePulse = True
if self._electronicsTab.currentWidget() == self._vClampCtrlBox:
clampMode = 'vclamp'
baseLevel = self.getFloatInput(self._holdingVEdit, self._holdingVLabel.text())
firstDelay = self.getFloatInput(self._holdingTimeEdit, self._holdingTimeLabel.text())
firstWidth = self.getFloatInput(self._prePulseTimeEdit, self._prePulseTimeLabel.text())
firstLevel = self.getFloatInput(self._prePulseVEdit, self._prePulseVLabel.text())
secondDelay = firstWidth
secondWidth = self.getFloatInput(self._clampTimeEdit, self._clampTimeLabel.text())
secondLevel = self.getFloatInput(self._clampVEdit, self._clampVLabel.text())
if not self._autoscaleAction.isChecked():
self._im_axes.set_ylim(-10.0, 10.0)
else:
clampMode = 'iclamp'
baseLevel = self.getFloatInput(self._baseCurrentEdit, self._baseCurrentLabel.text())
firstDelay = self.getFloatInput(self._firstDelayEdit, self._firstDelayLabel.text())
firstWidth = self.getFloatInput(self._firstPulseWidthEdit, self._firstPulseWidthLabel.text())
firstLevel = self.getFloatInput(self._firstPulseEdit, self._firstPulseLabel.text())
secondDelay = self.getFloatInput(self._secondDelayEdit, self._secondDelayLabel.text())
secondLevel = self.getFloatInput(self._secondPulseEdit, self._secondPulseLabel.text())
secondWidth = self.getFloatInput(self._secondPulseWidthEdit, self._secondPulseWidthLabel.text())
singlePulse = (self._pulseMode.currentIndex() == 0)
if not self._autoscaleAction.isChecked():
self._im_axes.set_ylim(-0.4, 0.4)
self.squid_setup.clamp_ckt.configure_pulses(baseLevel=baseLevel,
firstDelay=firstDelay,
firstWidth=firstWidth,
firstLevel=firstLevel,
secondDelay=secondDelay,
secondWidth=secondWidth,
secondLevel=secondLevel,
singlePulse=singlePulse)
if self._kConductanceToggle.isChecked():
self.squid_setup.squid_axon.specific_gK = 0.0
else:
self.squid_setup.squid_axon.specific_gK = SquidAxon.defaults['specific_gK']
if self._naConductanceToggle.isChecked():
self.squid_setup.squid_axon.specific_gNa = 0.0
else:
self.squid_setup.squid_axon.specific_gNa = SquidAxon.defaults['specific_gNa']
self.squid_setup.squid_axon.celsius = self.getFloatInput(self._temperatureEdit, self._temperatureLabel.text())
self.squid_setup.squid_axon.K_out = self.getFloatInput(self._kOutEdit, self._kOutLabel.text())
self.squid_setup.squid_axon.Na_out = self.getFloatInput(self._naOutEdit, self._naOutLabel.text())
self.squid_setup.squid_axon.K_in = self.getFloatInput(self._kInEdit, self._kInLabel.text())
self.squid_setup.squid_axon.Na_in = self.getFloatInput(self._naInEdit, self._naInLabel.text())
self.squid_setup.squid_axon.updateEk()
self.squid_setup.schedule(self._simdt, self._plotdt, clampMode)
# The following line is for use with Qthread
self.squid_setup.run(self._runtime)
self._updateAllPlots()
def _toggleDocking(self, on):
self._channelControlDock.setFloating(on)
self._electronicsDock.setFloating(on)
self._runControlDock.setFloating(on)
def _restoreDocks(self):
self._channelControlDock.setVisible(True)
self._electronicsDock.setVisible(True)
self._runControlDock.setVisible(True)
def _initActions(self):
self._runAction = QAction(self.tr('Run'), self)
self._runAction.setShortcut(self.tr('F5'))
self._runAction.setToolTip('Run simulation (F5)')
self._runAction.triggered.connect( self._runSlot)
self._resetToDefaultsAction = QAction(self.tr('Restore defaults'), self)
self._resetToDefaultsAction.setToolTip('Reset all settings to their default values')
self._resetToDefaultsAction.triggered.connect( self._useDefaults)
self._showLegendAction = QAction(self.tr('Display legend'), self)
self._showLegendAction.setCheckable(True)
self._showLegendAction.toggled.connect(self._showLegend)
self._showStatePlotAction = QAction(self.tr('State plot'), self)
self._showStatePlotAction.setCheckable(True)
self._showStatePlotAction.setChecked(False)
self._showStatePlotAction.toggled.connect(self._statePlotWidget.setVisible)
self._autoscaleAction = QAction(self.tr('Auto-scale plots'), self)
self._autoscaleAction.setCheckable(True)
self._autoscaleAction.setChecked(False)
self._autoscaleAction.toggled.connect(self._autoscale)
self._overlayAction = QAction('Overlay plots', self)
self._overlayAction.setCheckable(True)
self._overlayAction.setChecked(False)
self._dockAction = QAction('Undock all', self)
self._dockAction.setCheckable(True)
self._dockAction.setChecked(False)
# self._dockAction.toggle.connect( self._toggleDocking)
self._restoreDocksAction = QAction('Show all', self)
self._restoreDocksAction.triggered.connect( self._restoreDocks)
self._quitAction = QAction(self.tr('&Quit'), self)
self._quitAction.setShortcut(self.tr('Ctrl+Q'))
self._quitAction.triggered.connect(qApp.closeAllWindows)
def _createRunToolBar(self):
self._simToolBar = self.addToolBar(self.tr('Simulation control'))
self._simToolBar.addAction(self._quitAction)
self._simToolBar.addAction(self._runAction)
self._simToolBar.addAction(self._resetToDefaultsAction)
self._simToolBar.addAction(self._dockAction)
self._simToolBar.addAction(self._restoreDocksAction)
def _createPlotToolBar(self):
self._plotToolBar = self.addToolBar(self.tr('Plotting control'))
self._plotToolBar.addAction(self._showLegendAction)
self._plotToolBar.addAction(self._autoscaleAction)
self._plotToolBar.addAction(self._overlayAction)
self._plotToolBar.addAction(self._showStatePlotAction)
self._plotToolBar.addAction(self._helpAction)
self._plotToolBar.addAction(self._helpBiophysicsAction)
def _showLegend(self, on):
if on:
for axis in (self._plotFigure.axes + self._statePlotFigure.axes):
axis.legend().set_visible(True)
else:
for axis in (self._plotFigure.axes + self._statePlotFigure.axes):
axis.legend().set_visible(False)
self._plotCanvas.draw()
self._statePlotCanvas.draw()
def _autoscale(self, on):
if on:
for axis in (self._plotFigure.axes + self._statePlotFigure.axes):
axis.relim()
axis.set_autoscale_on(True)
axis.autoscale_view(True)
else:
for axis in self._plotFigure.axes:
axis.set_autoscale_on(False)
self._vm_axes.set_ylim(-20.0, 120.0)
self._g_axes.set_ylim(0.0, 0.5)
self._im_axes.set_ylim(-0.5, 0.5)
self._i_axes.set_ylim(-10, 10)
self._plotCanvas.draw()
self._statePlotCanvas.draw()
def _useDefaults(self):
self._runTimeEdit.setText('%g' % (self.defaults['runtime']))
self._simTimeStepEdit.setText('%g' % (self.defaults['simdt']))
self._overlayAction.setChecked(False)
self._naConductanceToggle.setChecked(False)
self._kConductanceToggle.setChecked(False)
self._kOutEdit.setText('%g' % (SquidGui.defaults['K_out']))
self._naOutEdit.setText('%g' % (SquidGui.defaults['Na_out']))
self._kInEdit.setText('%g' % (SquidGui.defaults['K_in']))
self._naInEdit.setText('%g' % (SquidGui.defaults['Na_in']))
self._temperatureEdit.setText('%g' % (SquidGui.defaults['temperature'] - CELSIUS_TO_KELVIN))
self._holdingVEdit.setText('%g' % (SquidGui.defaults['vclamp.holdingV']))
self._holdingTimeEdit.setText('%g' % (SquidGui.defaults['vclamp.holdingT']))
self._prePulseVEdit.setText('%g' % (SquidGui.defaults['vclamp.prepulseV']))
self._prePulseTimeEdit.setText('%g' % (SquidGui.defaults['vclamp.prepulseT']))
self._clampVEdit.setText('%g' % (SquidGui.defaults['vclamp.clampV']))
self._clampTimeEdit.setText('%g' % (SquidGui.defaults['vclamp.clampT']))
self._baseCurrentEdit.setText('%g' % (SquidGui.defaults['iclamp.baseI']))
self._firstPulseEdit.setText('%g' % (SquidGui.defaults['iclamp.firstI']))
self._firstDelayEdit.setText('%g' % (SquidGui.defaults['iclamp.firstD']))
self._firstPulseWidthEdit.setText('%g' % (SquidGui.defaults['iclamp.firstT']))
self._secondPulseEdit.setText('%g' % (SquidGui.defaults['iclamp.secondI']))
self._secondDelayEdit.setText('%g' % (SquidGui.defaults['iclamp.secondD']))
self._secondPulseWidthEdit.setText('%g' % (SquidGui.defaults['iclamp.secondT']))
self._pulseMode.setCurrentIndex(0)
def _onScroll(self, event):
if event.inaxes is None:
return
axes = event.inaxes
zoom = 0.0
if event.button == 'up':
zoom = -1.0
elif event.button == 'down':
zoom = 1.0
if zoom != 0.0:
self._plotNavigator.push_current()
axes.get_xaxis().zoom(zoom)
axes.get_yaxis().zoom(zoom)
self._plotCanvas.draw()
def closeEvent(self, event):
qApp.closeAllWindows()
def _showBioPhysicsHelp(self):
self._createHelpMessage()
self._helpMessageText.setText('<html><p>%s</p><p>%s</p><p>%s</p><p>%s</p><p>%s</p></html>' %
(tooltip_Nernst,
tooltip_Erest,
tooltip_KChan,
tooltip_NaChan,
tooltip_Im))
self._helpWindow.setVisible(True)
def _showRunningHelp(self):
self._createHelpMessage()
self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL))
self._helpWindow.setVisible(True)
def _createHelpMessage(self):
if hasattr(self, '_helpWindow'):
return
self._helpWindow = QWidget()
self._helpWindow.setWindowFlags(QtCore.Qt.Window)
layout = QVBoxLayout()
self._helpWindow.setLayout(layout)
self._helpMessageArea = QScrollArea()
self._helpMessageText = QTextBrowser()
self._helpMessageText.setOpenExternalLinks(True)
self._helpMessageArea.setWidget(self._helpMessageText)
layout.addWidget(self._helpMessageText)
self._squidGuiPath = os.path.dirname(os.path.abspath(__file__))
self._helpBaseURL = os.path.join(self._squidGuiPath,'help.html')
self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL))
self._helpMessageText.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self._helpMessageArea.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self._helpMessageText.setMinimumSize(800, 600)
self._closeHelpAction = QAction('Close', self)
self._closeHelpAction.triggered.connect(self._helpWindow.close)
# Setting the close event so that the ``Help`` button is
# unchecked when the help window is closed
self._helpWindow.closeEvent = lambda event: self._helpAction.setChecked(False)
self._helpTOCAction = QAction('Help running demo', self)
self._helpTOCAction.triggered.connect( self._jumpToHelpTOC)
# This panel is for putting two buttons using horizontal
# layout
panel = QFrame()
panel.setFrameStyle(QFrame.StyledPanel + QFrame.Raised)
layout.addWidget(panel)
layout = QHBoxLayout()
panel.setLayout(layout)
self._helpAction = QAction('Help running', self)
self._helpAction.triggered.connect(self._showRunningHelp)
self._helpBiophysicsAction = QAction('Help biophysics', self)
self._helpBiophysicsAction.triggered.connect(self._showBioPhysicsHelp)
self._helpTOCButton = QToolButton()
self._helpTOCButton.setDefaultAction(self._helpTOCAction)
self._helpBiophysicsButton = QToolButton()
self._helpBiophysicsButton.setDefaultAction(self._helpBiophysicsAction)
layout.addWidget(self._helpTOCButton)
layout.addWidget(self._helpBiophysicsButton)
self._closeHelpButton = QToolButton()
self._closeHelpButton.setDefaultAction(self._closeHelpAction)
layout.addWidget(self._closeHelpButton)
def _jumpToHelpTOC(self):
self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL))
class MainWindow(QWidget):
def __init__(self, app=None):
super(MainWindow, self).__init__()
self.app = app
global_layout = QVBoxLayout(self)
icon_path = absolute_path(solve_path('static/images/favicon.png'))
# NOTE: need to use objective message boxes instead of functions to set font
self.font = QFont("static/gfonts/Amiri-Regular.ttf", 12, QFont.Bold)
self.fonts = QFont("static/gfonts/Amiri-Regular.ttf", 10, QFont.Bold)
# Language support variable
self.current_language = 'en'
self.currently_running = False
icon = QIcon(icon_path)
self.initiate(icon)
self.set_center()
self.set_languages_list(global_layout)
self.set_about(icon_path, global_layout)
self.set_ips_and_ports(global_layout)
self.set_status(global_layout)
self.set_start_and_stop(global_layout)
self.setLayout(global_layout)
selected_ip_and_port = self.select_ips_ports_change()
self.Process = RunnerThread(selected_ip_and_port[1].split(',')[1],
selected_ip_and_port[0], self.app)
self.activateWindow()
self.show()
def initiate(self, icon):
self.setWindowTitle('Free Queue Manager ' + VERSION)
self.setGeometry(300, 300, 200, 150)
self.setMinimumWidth(500)
self.setMaximumWidth(500)
self.setMinimumHeight(400)
self.setMaximumHeight(400)
# Setting Icon
self.setWindowIcon(icon)
QToolTip.setFont(self.fonts)
def set_status(self, global_layout):
font = self.font
self.status_icon = QIcon(
absolute_path(solve_path('static/images/pause.png')))
self.status_icon_container = QLabel('Icond', self)
self.status_icon = self.status_icon.pixmap(70, 70, QIcon.Active,
QIcon.On)
self.status_icon_container.setPixmap(self.status_icon)
self.status_icon_container.setAlignment(QtCore.Qt.AlignCenter
| QtCore.Qt.AlignHCenter)
self.status_icon_container.setFont(font)
self.status_label = QLabel('Texted', self)
self.status_label.setText(
self.get_translation('Server is <u> Not running </u> <br>'))
self.status_label.setOpenExternalLinks(True)
self.status_label.setAlignment(QtCore.Qt.AlignCenter
| QtCore.Qt.AlignHCenter)
self.status_label.setFont(font)
self.status_label.setToolTip(
self.get_translation('Status of the server'))
self.status_icon_container.setToolTip(
self.get_translation('Status of the server'))
global_layout.addStretch()
global_layout.addWidget(self.status_icon_container)
global_layout.addWidget(self.status_label)
global_layout.addStretch()
def set_languages_list(self, global_layout):
self.languages = SUPPORTED_LANGUAGES
self.languages_list = QComboBox()
self.languages_list.addItems(list(self.languages.values()))
self.languages_list.setCurrentIndex(0)
self.languages_list.setToolTip(
self.get_translation('Select language to change the interface to'))
self.languages_list.currentIndexChanged.connect(
self.handle_language_change)
global_layout.addWidget(self.languages_list)
def handle_language_change(self):
self.current_language = list(
self.languages.keys())[self.languages_list.currentIndex()]
self.languages_list.setToolTip(
self.get_translation('Select language to change the interface to'))
self.title = self.get_translation('About FQM')
self.about_button.setToolTip(self.get_translation('About FQM'))
self.start_button.setText(self.get_translation('Start'))
self.start_button.setToolTip(self.get_translation('Start the server'))
self.stop_button.setText(self.get_translation('Stop'))
self.stop_button.setToolTip(self.get_translation('Stop the server'))
self.reset_button.setText(self.get_translation('Reset admin password'))
self.reset_button.setToolTip(
self.get_translation('Reset admin password'))
self.select_ip.setToolTip(
self.get_translation(
'Select network interface with IP, so the server runs on it'))
self.select_port.setToolTip(
self.get_translation(
'Select a port, so the server runs through it'))
self.status_label.setToolTip(
self.get_translation('Status of the server'))
self.status_icon_container.setToolTip(
self.get_translation('Status of the server'))
if self.currently_running:
current = self.select_ips_ports_change()
address = self.get_translation(
'Server is <u>Running</u> <br> On : ')
address += u"<a href='http://"
address += current[1].split(',')[1] + u":" + current[0]
address += u"'> http://" + current[1].split(
',')[1] + u":" + current[0]
address += u"</a>"
self.status_label.setText(address)
else:
self.status_label.setText(
self.get_translation('Server is <u> Not running </u> <br>'))
def get_translation(self, text):
current_language = list(
self.languages.keys())[self.languages_list.currentIndex()]
return gtranslator.translate(text, dest=[current_language])
def current_language(self):
return list(self.languages.keys())[self.languages_list.currentIndex()]
def set_ips_and_ports(self, global_layout):
ips = [' ,'.join(ip_tuple) for ip_tuple in get_accessible_ips()]
self.select_ip = QComboBox()
self.select_ip.addItems(ips)
self.select_ip.setToolTip(
self.get_translation(
'Select network interface with IP, so the server runs on it'))
self.select_port = QComboBox()
self.get_ports()
self.select_port.setToolTip(
self.get_translation(
'Select a port, so the server runs through it'))
self.select_ip.currentIndexChanged.connect(self.get_ports)
global_layout.addWidget(self.select_ip)
global_layout.addWidget(self.select_port)
def get_ports(self):
ip = self.select_ips_ports_change()[1].split(',')[1]
default_ports = ['5000', '8080', '3000', '80', '9931']
returned_ports = [
port for port in default_ports if is_port_available(ip, port)
]
while 10 > len(returned_ports):
returned_ports.append(get_random_available_port(ip))
self.select_port.clear()
self.select_port.addItems([str(port) for port in returned_ports])
def select_ips_ports_change(self):
return [self.select_port.currentText(), self.select_ip.currentText()]
def set_start_and_stop(self, global_layout):
grid = QVBoxLayout()
row_1 = QHBoxLayout()
row_2 = QHBoxLayout()
self.start_button = QPushButton('Start', self)
self.start_button.clicked.connect(self.start_server)
self.start_button.setFont(self.fonts)
self.start_button.setIcon(
QIcon(absolute_path(solve_path('static/images/play.png'))))
self.stop_button = QPushButton('Stop', self)
self.stop_button.clicked.connect(self.stop_server)
self.stop_button.setIcon(
QIcon(absolute_path(solve_path('static/images/pause.png'))))
self.reset_button = QPushButton(
self.get_translation('Reset admin password'))
self.reset_button.clicked.connect(self.reset_admin_pass)
self.start_button.setToolTip(self.get_translation('Start the server'))
self.stop_button.setToolTip(self.get_translation('Stop the server'))
self.stop_button.setEnabled(False)
self.stop_button.setFont(self.fonts)
row_1.addWidget(self.start_button)
row_1.addWidget(self.stop_button)
row_2.addWidget(self.reset_button)
grid.addLayout(row_1)
grid.addLayout(row_2)
global_layout.addLayout(grid)
def start_server(self):
current = self.select_ips_ports_change()
self.Process = RunnerThread(current[1].split(',')[1], current[0],
self.app)
self.Process.setTerminationEnabled(True)
if not self.Process.isRunning():
try:
self.Processport = current[0]
self.start_button.setEnabled(False)
self.reset_button.setEnabled(False)
self.stop_button.setEnabled(True)
self.select_ip.setEnabled(False)
self.select_port.setEnabled(False)
self.status_icon = QIcon(
absolute_path(solve_path('static/images/play.png')))
self.status_icon = self.status_icon.pixmap(
70, 70, QIcon.Active, QIcon.On)
self.status_icon_container.setPixmap(self.status_icon)
current = self.select_ips_ports_change()
address = self.get_translation(
'Server is <u>Running</u> <br> On : ')
address += "<a href='http://"
address += current[1].split(',')[1] + ":" + current[0]
address += "'> http://" + current[1].split(
',')[1] + ":" + current[0]
address += "</a>"
self.status_label.setText(address)
self.status_label.setFont(self.font)
self.Process.start()
self.currently_running = True
except Exception:
self.before_exit()
else:
self.before_exit()
def stop_server(self):
if self.Process.isRunning():
try:
if self.Process.isRunning:
self.Process.stop()
self.start_button.setEnabled(True)
self.stop_button.setEnabled(False)
self.reset_button.setEnabled(True)
self.select_ip.setEnabled(True)
self.select_port.setEnabled(True)
self.status_label.setText(
self.get_translation(
'Server is <u> Not running </u> <br>'))
# removing the last used port to avoid termination error
current_port_index = self.select_port.currentIndex()
self.select_port.removeItem(current_port_index)
self.get_ports()
self.currently_running = False
except Exception:
self.before_exit()
else:
self.before_exit()
def reset_admin_pass(self):
with self.app.app_context():
User.reset_default_password()
QMessageBox.information(
self, self.get_translation('Password reset'),
self.get_translation('Admin password was reset successfully.'),
QMessageBox.Ok)
def set_about(self, icon, global_layout):
def show_about():
message = u" <center> "
message += self.get_translation(
'All credit reserved to the author of FQM version '
) + VERSION + u" "
message += self.get_translation(
', This work is a free, open-source project licensed ')
message += self.get_translation(
' under Mozilla Public License version 2.0 . <br><br>')
message += self.get_translation(
' visit us for more infos and how-tos :<br> ')
message += u"<br> <b><a href='https://fqms.github.io/'>"
message += u"https://fqms.github.io </a> </b></center>"
title = self.get_translation('About FQM')
return QMessageBox.about(self, title, message)
self.about_button = QPushButton('', self)
self.about_button.setIcon(QIcon(icon))
self.about_button.setIconSize(QSize(150, 70))
self.about_button.setToolTip(self.get_translation('About FQM'))
self.about_button.clicked.connect(show_about)
global_layout.addWidget(self.about_button)
def closeEvent(self, event=None): # NOTE: Factory method
def exiting():
stop_tasks()
sys.exit(0)
if self.currently_running:
answer = self.exit_question(
self.get_translation('Exiting while running'),
self.get_translation(
'Are you really sure, you want to exit ?'))
if answer:
if event is not None:
event.accept()
if self.Process.isRunning():
self.Process.stop()
exiting()
else:
if event is not None:
event.ignore()
else:
if event is not None:
event.accept()
if self.Process.isRunning():
self.Process.stop()
exiting()
def exit_question(self, title, msg):
return QMessageBox.question(self, title, msg, QMessageBox.Yes
| QMessageBox.No) == QMessageBox.Yes
def before_exit(self):
if self.Process.isRunning():
self.Process.stop()
message = u"<center>"
message += self.get_translation(
' Opps, a critical error has occurred, we will be ')
message += self.get_translation(
' grateful if you can help fixing it, by reporting to us at : <br><br> '
)
message += u"<br><b><a href='https://fqms.github.io/'> "
message += u"https://fqms.github.io </a></b> </center>"
QMessageBox.critical(self, self.get_translation('Critical Error'),
message, QMessageBox.Ok)
def set_center(self):
geometry = self.frameGeometry()
centered = QDesktopWidget().availableGeometry().center()
geometry.moveCenter(centered)
self.move(geometry.topLeft())
class Dialog(toly_dialog.ToLyDialog):
def __init__(self, parent=None):
self.imp_prgm = "musicxml2ly"
self.userg = "musicxml_import"
self.noartCheck = QCheckBox()
self.norestCheck = QCheckBox()
self.nolayoutCheck = QCheckBox()
self.nobeamCheck = QCheckBox()
self.useAbsCheck = QCheckBox()
self.commMidiCheck = QCheckBox()
self.langCombo = QComboBox()
self.langLabel = QLabel()
self.impChecks = [self.noartCheck,
self.norestCheck,
self.nolayoutCheck,
self.nobeamCheck,
self.useAbsCheck,
self.commMidiCheck]
self.noartCheck.setObjectName("articulation-directions")
self.norestCheck.setObjectName("rest-positions")
self.nolayoutCheck.setObjectName("page-layout")
self.nobeamCheck.setObjectName("import-beaming")
self.useAbsCheck.setObjectName("absolute-mode")
self.commMidiCheck.setObjectName("comment-out-midi")
self.langCombo.addItem('')
self.langCombo.addItems(_langlist)
self.impExtra = [self.langLabel, self.langCombo]
super(Dialog, self).__init__(parent)
self.langCombo.currentIndexChanged.connect(self.makeCommandLine)
app.translateUI(self)
qutil.saveDialogSize(self, "musicxml_import/dialog/size", QSize(480, 260))
self.makeCommandLine()
self.loadSettings()
def translateUI(self):
self.setWindowTitle(app.caption(_("Import Music XML")))
self.noartCheck.setText(_("Import articulation directions"))
self.norestCheck.setText(_("Import rest positions"))
self.nolayoutCheck.setText(_("Import page layout"))
self.nobeamCheck.setText(_("Import beaming"))
self.useAbsCheck.setText(_("Pitches in absolute mode"))
self.commMidiCheck.setText(_("Comment out midi block"))
self.langLabel.setText(_("Language for pitch names"))
self.langCombo.setItemText(0, _("Default"))
self.buttons.button(QDialogButtonBox.Ok).setText(_("Run musicxml2ly"))
super(Dialog, self).translateUI()
def makeCommandLine(self):
"""Reads the widgets and builds a command line."""
cmd = ["$musicxml2ly"]
if self.useAbsCheck.isChecked():
cmd.append('-a')
if not self.noartCheck.isChecked():
cmd.append('--nd')
if not self.norestCheck.isChecked():
cmd.append('--nrp')
if not self.nolayoutCheck.isChecked():
cmd.append('--npl')
if not self.nobeamCheck.isChecked():
cmd.append('--no-beaming')
if not self.commMidiCheck.isChecked():
cmd.append('-m')
index = self.langCombo.currentIndex()
if index > 0:
cmd.append('--language=' + _langlist[index - 1])
cmd.append("$filename")
self.commandLine.setText(' '.join(cmd))
def loadSettings(self):
"""Get users previous settings."""
self.imp_default = [False, False, False, False, False, False]
self.settings = QSettings()
self.settings.beginGroup('musicxml_import')
super(Dialog, self).loadSettings()
lang = self.settings.value("language", "default", str)
try:
index = _langlist.index(lang)
except ValueError:
index = -1
self.langCombo.setCurrentIndex(index + 1)
def saveSettings(self):
"""Save users last settings."""
self.settings = QSettings()
self.settings.beginGroup('musicxml_import')
super(Dialog, self).saveSettings()
index = self.langCombo.currentIndex()
self.settings.setValue('language', 'default' if index == 0 else _langlist[index-1])
class dig_sentence_log(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
client = MongoClient('localhost', 27017)
db = client.taroko
self.collection_log = db.log
self.collection_ori = db.origin
self.main_layout = QVBoxLayout()
sentence_widget = QFormLayout()
self.select_layout = QHBoxLayout()
self.show_all_sentences = QCheckBox('包含已回答句子')
self.show_all_sentences.stateChanged.connect(self.state_changed)
self.sentences_id = []
self.log_list = QComboBox()
self.load_sentence()
self.log_list.currentIndexChanged.connect(self.show_selected_item)
self.remove_btn = QPushButton('刪除紀錄')
self.remove_btn.clicked.connect(self.remove_btn_method)
self.select_layout.addWidget(self.log_list)
self.select_layout.addWidget(self.show_all_sentences)
self.select_layout.addWidget(self.remove_btn)
temp = self.collection_log.find_one({'answer': ''})
self.sentence = QTextEdit()
# self.sentence.setText(str(temp['sentence']))
self.answer = QTextEdit()
sentence_widget.addRow(QLabel('無法回答問句'), self.select_layout)
sentence_widget.addRow(QLabel('問句'), self.sentence)
sentence_widget.addRow(QLabel('答案'), self.answer)
button_layout = QHBoxLayout()
save_btn = QPushButton("儲存")
save_btn.clicked.connect(self.save_btn_method)
cancel_btn = QPushButton("取消")
cancel_btn.clicked.connect(self.cancel_btn_method)
button_layout.addWidget(save_btn)
button_layout.addWidget(cancel_btn)
self.main_layout.addLayout(sentence_widget)
self.main_layout.addLayout(button_layout)
self.setLayout(self.main_layout)
@pyqtSlot()
def load_sentence(self):
for _ in range(len(self.sentences_id)):
self.log_list.removeItem(0)
self.sentences_id = []
if self.show_all_sentences.checkState():
for row in self.collection_log.find():
self.sentences_id.append(row['_id'])
self.log_list.addItem(str(row['sentence']))
if self.log_list.count() > len(self.sentences_id):
if len(self.sentences_id) > 0:
self.log_list.removeItem(0)
else:
for row in self.collection_log.find({'answer': ''}):
self.sentences_id.append(row['_id'])
self.log_list.addItem(str(row['sentence']))
@pyqtSlot()
def show_selected_item(self):
data = self.collection_log.find_one(
{'_id': self.sentences_id[self.log_list.currentIndex()]})
self.sentence.setText(self.log_list.currentText())
self.answer.setText(data['answer'])
@pyqtSlot()
def state_changed(self):
self.sentence.clear()
self.answer.clear()
self.load_sentence()
@pyqtSlot()
def remove_btn_method(self):
if len(self.sentences_id) > 0:
result = QMessageBox.question(
self, '警告', '確定要刪除"{0}"嗎?'.format(self.log_list.currentText()),
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if result == QMessageBox.Yes:
self.remove_item_from_combobox()
else:
pass
else:
QMessageBox.information(self, '警告', '目前沒有句子')
def remove_item_from_combobox(self):
current_index = self.log_list.currentIndex()
self.collection_log.remove({'_id': self.sentences_id[current_index]})
del self.sentences_id[current_index]
if self.log_list.count() == 1:
self.log_list.setItemText(0, '')
else:
self.log_list.removeItem(current_index)
@pyqtSlot()
def save_btn_method(self):
if len(self.sentences_id) > 0:
data = {
'uuid': self.collection_ori.find().count(),
'sentence': self.sentence.toPlainText(),
'answer': self.answer.toPlainText(),
'url': '',
'segmentation': '',
'pos': ''
}
self.collection_ori.insert(data)
QMessageBox.information(
self, '提醒', '已儲存"{}"'.format(self.sentence.toPlainText()))
self.remove_item_from_combobox()
else:
QMessageBox.information(self, '警告', '目前沒有句子')
@pyqtSlot()
def cancel_btn_method(self):
data = self.collection_log.find_one(
{'_id': self.sentences_id[self.log_list.currentIndex()]})
self.sentence.setText(str(data['sentence']))
self.answer.setText(str(data['answer']))
class PreferencesPanel(QDialog):
def __init__(self, parent, app):
# The flags we pass are that so we don't get the "What's this" button in the title bar
QDialog.__init__(self, parent, Qt.WindowTitleHint | Qt.WindowSystemMenuHint)
self.app = app
self._setupUi()
self.dateFormatEdit.editingFinished.connect(self.dateFormatEdited)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
def _setupUi(self):
self.setWindowTitle(tr("Preferences"))
self.resize(332, 170)
self.verticalLayout = QVBoxLayout(self)
self.formLayout = QFormLayout()
self.autoSaveIntervalSpinBox = QSpinBox(self)
self.autoSaveIntervalSpinBox.setMaximumSize(QSize(70, 0xffffff))
self.label_5 = QLabel(tr("minute(s) (0 for none)"), self)
self.formLayout.addRow(
tr("Auto-save interval:"),
horizontalWrap([self.autoSaveIntervalSpinBox, self.label_5])
)
self.dateFormatEdit = QLineEdit(self)
self.dateFormatEdit.setMaximumSize(QSize(140, 0xffffff))
self.formLayout.addRow(tr("Date format:"), self.dateFormatEdit)
self.fontSizeSpinBox = QSpinBox()
self.fontSizeSpinBox.setMinimum(5)
self.fontSizeSpinBox.setMaximumSize(QSize(70, 0xffffff))
self.formLayout.addRow(tr("Font size:"), self.fontSizeSpinBox)
self.languageComboBox = QComboBox(self)
LANGNAMES = get_langnames()
for lang in SUPPORTED_LANGUAGES:
self.languageComboBox.addItem(LANGNAMES[lang])
self.languageComboBox.setMaximumSize(QSize(140, 0xffffff))
self.formLayout.addRow(tr("Language:"), self.languageComboBox)
self.verticalLayout.addLayout(self.formLayout)
self.scopeDialogCheckBox = QCheckBox(tr("Show scope dialog when modifying a scheduled transaction"), self)
self.verticalLayout.addWidget(self.scopeDialogCheckBox)
self.autoDecimalPlaceCheckBox = QCheckBox(tr("Automatically place decimals when typing"), self)
self.verticalLayout.addWidget(self.autoDecimalPlaceCheckBox)
self.debugModeCheckBox = QCheckBox(tr("Debug mode (restart required)"), self)
self.verticalLayout.addWidget(self.debugModeCheckBox)
self.verticalLayout.addItem(verticalSpacer())
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel|QDialogButtonBox.Ok)
self.verticalLayout.addWidget(self.buttonBox)
def load(self):
appm = self.app.model
self.autoSaveIntervalSpinBox.setValue(appm.autosave_interval)
self.dateFormatEdit.setText(self.app.prefs.dateFormat)
self.fontSizeSpinBox.setValue(self.app.prefs.tableFontSize)
self.scopeDialogCheckBox.setChecked(appm.show_schedule_scope_dialog)
self.autoDecimalPlaceCheckBox.setChecked(appm.auto_decimal_place)
self.debugModeCheckBox.setChecked(self.app.prefs.debugMode)
try:
langindex = SUPPORTED_LANGUAGES.index(self.app.prefs.language)
except ValueError:
langindex = 0
self.languageComboBox.setCurrentIndex(langindex)
def save(self):
restartRequired = False
appm = self.app.model
appm.autosave_interval = self.autoSaveIntervalSpinBox.value()
if self.dateFormatEdit.text() != self.app.prefs.dateFormat:
restartRequired = True
self.app.prefs.dateFormat = self.dateFormatEdit.text()
self.app.prefs.tableFontSize = self.fontSizeSpinBox.value()
appm.show_schedule_scope_dialog = self.scopeDialogCheckBox.isChecked()
appm.auto_decimal_place = self.autoDecimalPlaceCheckBox.isChecked()
self.app.prefs.debugMode = self.debugModeCheckBox.isChecked()
lang = SUPPORTED_LANGUAGES[self.languageComboBox.currentIndex()]
oldlang = self.app.prefs.language
if oldlang not in SUPPORTED_LANGUAGES:
oldlang = 'en'
if lang != oldlang:
restartRequired = True
self.app.prefs.language = lang
if restartRequired:
QMessageBox.information(self, "", tr("moneyGuru has to restart for these changes to take effect"))
#--- Signals
def dateFormatEdited(self):
self.dateFormatEdit.setText(clean_format(self.dateFormatEdit.text()))
class ArmValuesWidget(QWidget):
def __init__(self, servos):
super(ArmValuesWidget, self).__init__()
self.ids = [s[1] for s in servos]
self._widgets = {}
layout = QGridLayout()
i = 1
layout.addWidget(QLabel('Goal position'), 0, 1)
layout.addWidget(QLabel('Enable'), 0, 2)
layout.addWidget(QLabel('Torque limit'), 0, 3)
layout.addWidget(QLabel('Position'), 0, 4)
layout.addWidget(QLabel('Speed'), 0, 5)
layout.addWidget(QLabel('Load'), 0, 6)
for k, id_ in servos:
wid_goal_pos = QSpinBox()
wid_goal_pos.setRange(0, 4096)
cb = (lambda b: lambda: self._on_goal_position_changed(b))(id_)
wid_goal_pos.valueChanged.connect(cb)
wid_torque_enable = QCheckBox()
cb = (lambda b: lambda: self._on_torque_enable_changed(b))(id_)
wid_torque_enable.stateChanged.connect(cb)
wid_torque_limit = QSpinBox()
wid_torque_limit.setRange(0, 4096)
cb = (lambda b: lambda: self._on_torque_limit_changed(b))(id_)
wid_torque_limit.valueChanged.connect(cb)
wid_current_pos = QLineEdit()
wid_current_pos.setReadOnly(True)
wid_current_speed = QLineEdit()
wid_current_speed.setReadOnly(True)
wid_current_load = QLineEdit()
wid_current_load.setReadOnly(True)
layout.addWidget(QLabel(k), i, 0)
layout.addWidget(wid_goal_pos, i, 1)
layout.addWidget(wid_torque_enable, i, 2)
layout.addWidget(wid_torque_limit, i, 3)
layout.addWidget(wid_current_pos, i, 4)
layout.addWidget(wid_current_speed, i, 5)
layout.addWidget(wid_current_load, i, 6)
self._widgets[id_] = (wid_goal_pos, wid_torque_enable,
wid_torque_limit, wid_current_pos,
wid_current_speed, wid_current_load)
i += 1
self._button_read_state = QPushButton('read')
self._button_copy_state = QPushButton('copy')
self._button_load_state = QPushButton('<<')
self._button_save_state = QPushButton('>>')
self._combobox_position = QComboBox()
self._combobox_speed = QComboBox()
self._combobox_torque = QComboBox()
for s in speeds:
self._combobox_speed.addItem(str(s))
for n in cfg.robot_config.dynamixels_torques.keys():
self._combobox_torque.addItem(n)
self._button_go_position = QPushButton('go')
self._button_reload = QPushButton('reload')
self._button_save_file = QPushButton('save')
layout.addWidget(self._button_read_state, i, 0)
layout.addWidget(self._button_copy_state, i, 1)
layout.addWidget(self._button_load_state, i, 2)
layout.addWidget(self._button_save_state, i, 3)
layout.addWidget(self._combobox_position, i + 1, 0, 1, 2)
layout.addWidget(self._combobox_speed, i + 1, 2)
layout.addWidget(self._combobox_torque, i + 1, 3)
layout.addWidget(self._button_go_position, i + 1, 4)
layout.addWidget(self._button_reload, i, 4)
layout.addWidget(self._button_save_file, i, 5)
self.setLayout(layout)
#self._button_get_position.clicked.connect(self._get_position)
self._button_copy_state.clicked.connect(self._copy_state)
self._button_read_state.clicked.connect(self.read_dynamixels_state)
self._button_load_state.clicked.connect(self._load_state)
self._button_save_state.clicked.connect(self._save_state)
self._button_go_position.clicked.connect(self._go_position)
self._button_reload.clicked.connect(self.reload_positions)
self._button_save_file.clicked.connect(self._save_file)
def update_dynamixel_state(self, id_, values):
if id_ in self._widgets:
wids = self._widgets[id_]
wids[3].setText(str(values[0]))
velocity = values[1] & ((1 << 10) - 1)
if values[1] & (1 << 10):
velocity = -velocity
wids[4].setText(str(values[1]))
load = values[2] & ((1 << 10) - 1)
if values[2] & (1 << 10):
load = -load
wids[5].setText(str(load))
#wids[6].setText(str(values[3]))
#wids[7].setText(str(values[4]))
def set_client(self, client):
self._client = client
self._client.dynamixel_registers.connect(self._on_dynamixel_registers)
def read_dynamixels_state(self):
for id_ in self.ids:
self._client.send_message(message_types.DbgDynamixelGetRegisters,
struct.pack('<BBB', id_, 0x24, 8))
def reload_positions(self):
cfg.robot_config.load_dynamixels_config()
self._combobox_position.clear()
i = 0
for k, v in cfg.robot_config.dynamixels_positions.items():
self._combobox_position.addItem(k)
msg = struct.pack('<BB', 0, i) + b''.join(
[struct.pack('<H', p) for p in v])
self._client.send_message(160, msg)
def _on_dynamixel_registers(self, id_, address, data):
if address == 36 and len(data) == 8:
vals = struct.unpack('<HHHBB', data)
self.update_dynamixel_state(id_, vals)
def _copy_state(self):
for wids in self._widgets.values():
try:
wids[0].setValue(int(wids[3].text()))
except:
pass
def _get_position(self):
pos_index = self._combobox_position.currentIndex()
pos = list(cfg.dynamixels_positions.items())[pos_index][1]
for i in range(len(pos)):
self._widgets[self.ids[i]][0].setValue(pos[i])
def _on_goal_position_changed(self, id_):
wids = self._widgets[id_]
# Set position
if wids[1].isChecked():
self._client.send_message(
message_types.DbgDynamixelSetGoalPosition,
struct.pack('<BH', id_, wids[0].value()))
# Read registers
self._client.send_message(message_types.DbgDynamixelGetRegisters,
struct.pack('<BBB', id_, 0x24, 8))
def _on_torque_limit_changed(self, id_):
wids = self._widgets[id_]
# Set position
if wids[1].isChecked():
self._client.send_message(message_types.DbgDynamixelSetTorqueLimit,
struct.pack('<BH', id_, wids[2].value()))
# Read registers
self._client.send_message(message_types.DbgDynamixelGetRegisters,
struct.pack('<BBB', id_, 0x24, 8))
def _on_torque_enable_changed(self, id_):
wids = self._widgets[id_]
# Set torque enable
self._client.send_message(message_types.DbgDynamixelSetTorqueEnable,
struct.pack('<BB', id_, wids[1].isChecked()))
# Read registers
self._client.send_message(message_types.DbgDynamixelGetRegisters,
struct.pack('<BBB', id_, 0x24, 8))
def _go_position(self):
pos_index = self._combobox_position.currentIndex()
pos = list(cfg.robot_config.dynamixels_positions.items())[pos_index][1]
#first update position
msg = struct.pack('<BB', 0, pos_index)
msg = msg + b''.join([struct.pack('<H', v) for v in pos])
self._client.send_message(message_types.DbgArmsSetPose, msg)
self._client.send_message(
message_types.DbgArmsGoToPosition,
struct.pack('<BBH', pos_index,
self._combobox_torque.currentIndex(),
speeds[self._combobox_speed.currentIndex()]))
def _load_state(self):
pos_index = self._combobox_position.currentIndex()
pos = list(cfg.robot_config.dynamixels_positions.items())[pos_index][1]
for i in range(len(self._widgets)):
wids = self._widgets[cfg.robot_config.yaml['dynamixels'][i]['id']]
wids[0].setValue(pos[i])
def _save_state(self):
pos_index = self._combobox_position.currentIndex()
pos = list(cfg.robot_config.dynamixels_positions.items())[pos_index][1]
for i in range(len(self._widgets)):
wids = self._widgets[cfg.robot_config.yaml['dynamixels'][i]['id']]
pos[i] = wids[0].value()
def _save_file(self):
of = open(cfg.robot_config.path + '/saved_dynamixel_positions.txt',
'w')
of.write('name')
for s in cfg.robot_config.yaml['dynamixels']:
of.write(',' + s['name'])
of.write('\n')
for k, v in cfg.robot_config.dynamixels_positions.items():
of.write(k)
for e in v:
of.write(',' + str(e))
of.write('\n')
of.close()
def update_values(self, values):
for k, v in values.items():
self._widgets[k].setValue(v)
class SettingsDialog(QDialog):
worker = None
config = None
configfile = None
saved = QtCore.pyqtSignal()
def __init__(self, parent, worker, config, configfile):
QDialog.__init__(self, parent)
self.worker = worker
self.config = config
self.configfile = configfile
self.setStyleSheet("QGroupBox { font-weight: bold; } ")
self.setWindowTitle('Settings')
layout = QGridLayout()
# Categories
self.category_list = QListWidget()
category_media = QListWidgetItem(getIcon('media-playback-start'), 'Media', self.category_list)
category_sync = QListWidgetItem(getIcon('view-refresh'), 'Sync', self.category_list)
category_ui = QListWidgetItem(getIcon('window-new'), 'User Interface', self.category_list)
category_theme = QListWidgetItem(getIcon('applications-graphics'), 'Theme', self.category_list)
self.category_list.setSelectionMode(QAbstractItemView.SingleSelection)
self.category_list.setCurrentRow(0)
self.category_list.setMaximumWidth(self.category_list.sizeHintForColumn(0) + 15)
self.category_list.setFocus()
self.category_list.currentItemChanged.connect(self.s_switch_page)
# Media tab
page_media = QWidget()
page_media_layout = QVBoxLayout()
page_media_layout.setAlignment(QtCore.Qt.AlignTop)
# Group: Media settings
g_media = QGroupBox('Media settings')
g_media.setFlat(True)
g_media_layout = QFormLayout()
self.tracker_enabled = QCheckBox()
self.tracker_enabled.toggled.connect(self.tracker_type_change)
self.tracker_type = QComboBox()
for (n, label) in utils.available_trackers:
self.tracker_type.addItem(label, n)
self.tracker_type.currentIndexChanged.connect(self.tracker_type_change)
self.tracker_interval = QSpinBox()
self.tracker_interval.setRange(5, 1000)
self.tracker_interval.setMaximumWidth(60)
self.tracker_process = QLineEdit()
self.tracker_update_wait = QSpinBox()
self.tracker_update_wait.setRange(0, 1000)
self.tracker_update_wait.setMaximumWidth(60)
self.tracker_update_close = QCheckBox()
self.tracker_update_prompt = QCheckBox()
self.tracker_not_found_prompt = QCheckBox()
g_media_layout.addRow('Enable tracker', self.tracker_enabled)
g_media_layout.addRow('Tracker type', self.tracker_type)
g_media_layout.addRow('Tracker interval (seconds)', self.tracker_interval)
g_media_layout.addRow('Process name (regex)', self.tracker_process)
g_media_layout.addRow('Wait before updating (seconds)', self.tracker_update_wait)
g_media_layout.addRow('Wait until the player is closed', self.tracker_update_close)
g_media_layout.addRow('Ask before updating', self.tracker_update_prompt)
g_media_layout.addRow('Ask to add new shows', self.tracker_not_found_prompt)
g_media.setLayout(g_media_layout)
# Group: Plex settings
g_plex = QGroupBox('Plex Media Server')
g_plex.setFlat(True)
self.plex_host = QLineEdit()
self.plex_port = QLineEdit()
self.plex_user = QLineEdit()
self.plex_passw = QLineEdit()
self.plex_passw.setEchoMode(QLineEdit.Password)
self.plex_obey_wait = QCheckBox()
g_plex_layout = QGridLayout()
g_plex_layout.addWidget(QLabel('Host and Port'), 0, 0, 1, 1)
g_plex_layout.addWidget(self.plex_host, 0, 1, 1, 1)
g_plex_layout.addWidget(self.plex_port, 0, 2, 1, 2)
g_plex_layout.addWidget(QLabel('Use "wait before updating" time'), 1, 0, 1, 1)
g_plex_layout.addWidget(self.plex_obey_wait, 1, 2, 1, 1)
g_plex_layout.addWidget(QLabel('myPlex login (claimed server)'), 2, 0, 1, 1)
g_plex_layout.addWidget(self.plex_user, 2, 1, 1, 1)
g_plex_layout.addWidget(self.plex_passw, 2, 2, 1, 2)
g_plex.setLayout(g_plex_layout)
# Group: Library
g_playnext = QGroupBox('Library')
g_playnext.setFlat(True)
self.player = QLineEdit()
self.player_browse = QPushButton('Browse...')
self.player_browse.clicked.connect(self.s_player_browse)
lbl_searchdirs = QLabel('Media directories')
lbl_searchdirs.setAlignment(QtCore.Qt.AlignTop)
self.searchdirs = QListWidget()
self.searchdirs_add = QPushButton('Add...')
self.searchdirs_add.clicked.connect(self.s_searchdirs_add)
self.searchdirs_remove = QPushButton('Remove')
self.searchdirs_remove.clicked.connect(self.s_searchdirs_remove)
self.searchdirs_buttons = QVBoxLayout()
self.searchdirs_buttons.setAlignment(QtCore.Qt.AlignTop)
self.searchdirs_buttons.addWidget(self.searchdirs_add)
self.searchdirs_buttons.addWidget(self.searchdirs_remove)
self.searchdirs_buttons.addWidget(QSplitter())
self.library_autoscan = QCheckBox()
self.scan_whole_list = QCheckBox()
self.library_full_path = QCheckBox()
g_playnext_layout = QGridLayout()
g_playnext_layout.addWidget(QLabel('Player'), 0, 0, 1, 1)
g_playnext_layout.addWidget(self.player, 0, 1, 1, 1)
g_playnext_layout.addWidget(self.player_browse, 0, 2, 1, 1)
g_playnext_layout.addWidget(lbl_searchdirs, 1, 0, 1, 1)
g_playnext_layout.addWidget(self.searchdirs, 1, 1, 1, 1)
g_playnext_layout.addLayout(self.searchdirs_buttons, 1, 2, 1, 1)
g_playnext_layout.addWidget(QLabel('Rescan Library at startup'), 2, 0, 1, 2)
g_playnext_layout.addWidget(self.library_autoscan, 2, 2, 1, 1)
g_playnext_layout.addWidget(QLabel('Scan through whole list'), 3, 0, 1, 2)
g_playnext_layout.addWidget(self.scan_whole_list, 3, 2, 1, 1)
g_playnext_layout.addWidget(QLabel('Take subdirectory name into account'), 4, 0, 1, 2)
g_playnext_layout.addWidget(self.library_full_path, 4, 2, 1, 1)
g_playnext.setLayout(g_playnext_layout)
# Media form
page_media_layout.addWidget(g_media)
page_media_layout.addWidget(g_plex)
page_media_layout.addWidget(g_playnext)
page_media.setLayout(page_media_layout)
# Sync tab
page_sync = QWidget()
page_sync_layout = QVBoxLayout()
page_sync_layout.setAlignment(QtCore.Qt.AlignTop)
# Group: Autoretrieve
g_autoretrieve = QGroupBox('Autoretrieve')
g_autoretrieve.setFlat(True)
self.autoretrieve_off = QRadioButton('Disabled')
self.autoretrieve_always = QRadioButton('Always at start')
self.autoretrieve_days = QRadioButton('After n days')
self.autoretrieve_days.toggled.connect(self.s_autoretrieve_days)
self.autoretrieve_days_n = QSpinBox()
self.autoretrieve_days_n.setRange(1, 100)
g_autoretrieve_layout = QGridLayout()
g_autoretrieve_layout.setColumnStretch(0, 1)
g_autoretrieve_layout.addWidget(self.autoretrieve_off, 0, 0, 1, 1)
g_autoretrieve_layout.addWidget(self.autoretrieve_always, 1, 0, 1, 1)
g_autoretrieve_layout.addWidget(self.autoretrieve_days, 2, 0, 1, 1)
g_autoretrieve_layout.addWidget(self.autoretrieve_days_n, 2, 1, 1, 1)
g_autoretrieve.setLayout(g_autoretrieve_layout)
# Group: Autosend
g_autosend = QGroupBox('Autosend')
g_autosend.setFlat(True)
self.autosend_off = QRadioButton('Disabled')
self.autosend_always = QRadioButton('Immediately after every change')
self.autosend_minutes = QRadioButton('After n minutes')
self.autosend_minutes.toggled.connect(self.s_autosend_minutes)
self.autosend_minutes_n = QSpinBox()
self.autosend_minutes_n.setRange(1, 1000)
self.autosend_size = QRadioButton('After the queue reaches n items')
self.autosend_size.toggled.connect(self.s_autosend_size)
self.autosend_size_n = QSpinBox()
self.autosend_size_n.setRange(2, 20)
self.autosend_at_exit = QCheckBox('At exit')
g_autosend_layout = QGridLayout()
g_autosend_layout.setColumnStretch(0, 1)
g_autosend_layout.addWidget(self.autosend_off, 0, 0, 1, 1)
g_autosend_layout.addWidget(self.autosend_always, 1, 0, 1, 1)
g_autosend_layout.addWidget(self.autosend_minutes, 2, 0, 1, 1)
g_autosend_layout.addWidget(self.autosend_minutes_n, 2, 1, 1, 1)
g_autosend_layout.addWidget(self.autosend_size, 3, 0, 1, 1)
g_autosend_layout.addWidget(self.autosend_size_n, 3, 1, 1, 1)
g_autosend_layout.addWidget(self.autosend_at_exit, 4, 0, 1, 1)
g_autosend.setLayout(g_autosend_layout)
# Group: Extra
g_extra = QGroupBox('Additional options')
g_extra.setFlat(True)
self.auto_status_change = QCheckBox('Change status automatically')
self.auto_status_change.toggled.connect(self.s_auto_status_change)
self.auto_status_change_if_scored = QCheckBox('Change status automatically only if scored')
self.auto_date_change = QCheckBox('Change start and finish dates automatically')
g_extra_layout = QVBoxLayout()
g_extra_layout.addWidget(self.auto_status_change)
g_extra_layout.addWidget(self.auto_status_change_if_scored)
g_extra_layout.addWidget(self.auto_date_change)
g_extra.setLayout(g_extra_layout)
# Sync layout
page_sync_layout.addWidget(g_autoretrieve)
page_sync_layout.addWidget(g_autosend)
page_sync_layout.addWidget(g_extra)
page_sync.setLayout(page_sync_layout)
# UI tab
page_ui = QWidget()
page_ui_layout = QFormLayout()
page_ui_layout.setAlignment(QtCore.Qt.AlignTop)
# Group: Icon
g_icon = QGroupBox('Notification Icon')
g_icon.setFlat(True)
self.tray_icon = QCheckBox('Show tray icon')
self.tray_icon.toggled.connect(self.s_tray_icon)
self.close_to_tray = QCheckBox('Close to tray')
self.start_in_tray = QCheckBox('Start minimized to tray')
self.tray_api_icon = QCheckBox('Use API icon as tray icon')
self.notifications = QCheckBox('Show notification when tracker detects new media')
g_icon_layout = QVBoxLayout()
g_icon_layout.addWidget(self.tray_icon)
g_icon_layout.addWidget(self.close_to_tray)
g_icon_layout.addWidget(self.start_in_tray)
g_icon_layout.addWidget(self.tray_api_icon)
g_icon_layout.addWidget(self.notifications)
g_icon.setLayout(g_icon_layout)
# Group: Window
g_window = QGroupBox('Window')
g_window.setFlat(True)
self.remember_geometry = QCheckBox('Remember window size and position')
self.remember_columns = QCheckBox('Remember column layouts and widths')
self.columns_per_api = QCheckBox('Use different visible columns per API')
g_window_layout = QVBoxLayout()
g_window_layout.addWidget(self.remember_geometry)
g_window_layout.addWidget(self.remember_columns)
g_window_layout.addWidget(self.columns_per_api)
g_window.setLayout(g_window_layout)
# Group: Lists
g_lists = QGroupBox('Lists')
g_lists.setFlat(True)
self.filter_bar_position = QComboBox()
filter_bar_positions = [(FilterBar.PositionHidden, 'Hidden'),
(FilterBar.PositionAboveLists, 'Above lists'),
(FilterBar.PositionBelowLists, 'Below lists')]
for (n, label) in filter_bar_positions:
self.filter_bar_position.addItem(label, n)
self.inline_edit = QCheckBox('Enable in-line editing')
g_lists_layout = QFormLayout()
g_lists_layout.addRow('Filter bar position:', self.filter_bar_position)
g_lists_layout.addRow(self.inline_edit)
g_lists.setLayout(g_lists_layout)
# UI layout
page_ui_layout.addWidget(g_icon)
page_ui_layout.addWidget(g_window)
page_ui_layout.addWidget(g_lists)
page_ui.setLayout(page_ui_layout)
# Theming tab
page_theme = QWidget()
page_theme_layout = QFormLayout()
page_theme_layout.setAlignment(QtCore.Qt.AlignTop)
# Group: Episode Bar
g_ep_bar = QGroupBox('Episode Bar')
g_ep_bar.setFlat(True)
self.ep_bar_style = QComboBox()
ep_bar_styles = [(ShowsTableDelegate.BarStyleBasic, 'Basic'),
(ShowsTableDelegate.BarStyle04, 'Trackma'),
(ShowsTableDelegate.BarStyleHybrid, 'Hybrid')]
for (n, label) in ep_bar_styles:
self.ep_bar_style.addItem(label, n)
self.ep_bar_style.currentIndexChanged.connect(self.s_ep_bar_style)
self.ep_bar_text = QCheckBox('Show text label')
g_ep_bar_layout = QFormLayout()
g_ep_bar_layout.addRow('Style:', self.ep_bar_style)
g_ep_bar_layout.addRow(self.ep_bar_text)
g_ep_bar.setLayout(g_ep_bar_layout)
# Group: Colour scheme
g_scheme = QGroupBox('Color Scheme')
g_scheme.setFlat(True)
col_tabs = [('rows', '&Row highlights'),
('progress', '&Progress widget')]
self.colors = {}
self.colors['rows'] = [('is_playing', 'Playing'),
('is_queued', 'Queued'),
('new_episode', 'New Episode'),
('is_airing', 'Airing'),
('not_aired', 'Unaired')]
self.colors['progress'] = [('progress_bg', 'Background'),
('progress_fg', 'Watched bar'),
('progress_sub_bg', 'Aired episodes'),
('progress_sub_fg', 'Stored episodes'),
('progress_complete', 'Complete')]
self.color_buttons = []
self.syscolor_buttons = []
g_scheme_layout = QGridLayout()
tw_scheme = QTabWidget()
for (key, tab_title) in col_tabs:
page = QFrame()
page_layout = QGridLayout()
col = 0
# Generate widgets from the keys and values
for (key, label) in self.colors[key]:
self.color_buttons.append(QPushButton())
# self.color_buttons[-1].setStyleSheet('background-color: ' + getColor(self.config['colors'][key]).name())
self.color_buttons[-1].setFocusPolicy(QtCore.Qt.NoFocus)
self.color_buttons[-1].clicked.connect(self.s_color_picker(key, False))
self.syscolor_buttons.append(QPushButton('System Colors'))
self.syscolor_buttons[-1].clicked.connect(self.s_color_picker(key, True))
page_layout.addWidget(QLabel(label), col, 0, 1, 1)
page_layout.addWidget(self.color_buttons[-1], col, 1, 1, 1)
page_layout.addWidget(self.syscolor_buttons[-1], col, 2, 1, 1)
col += 1
page.setLayout(page_layout)
tw_scheme.addTab(page, tab_title)
g_scheme_layout.addWidget(tw_scheme)
g_scheme.setLayout(g_scheme_layout)
# UI layout
page_theme_layout.addWidget(g_ep_bar)
page_theme_layout.addWidget(g_scheme)
page_theme.setLayout(page_theme_layout)
# Content
self.contents = QStackedWidget()
self.contents.addWidget(page_media)
self.contents.addWidget(page_sync)
self.contents.addWidget(page_ui)
self.contents.addWidget(page_theme)
if pyqt_version is not 5:
self.contents.layout().setMargin(0)
# Bottom buttons
bottombox = QDialogButtonBox(
QDialogButtonBox.Ok
| QDialogButtonBox.Apply
| QDialogButtonBox.Cancel
)
bottombox.accepted.connect(self.s_save)
bottombox.button(QDialogButtonBox.Apply).clicked.connect(self._save)
bottombox.rejected.connect(self.reject)
# Main layout finish
layout.addWidget(self.category_list, 0, 0, 1, 1)
layout.addWidget(self.contents, 0, 1, 1, 1)
layout.addWidget(bottombox, 1, 0, 1, 2)
layout.setColumnStretch(1, 1)
self._load()
self.update_colors()
self.setLayout(layout)
def _add_dir(self, path):
self.searchdirs.addItem(path)
def _load(self):
engine = self.worker.engine
tracker_type = self.tracker_type.findData(engine.get_config('tracker_type'))
autoretrieve = engine.get_config('autoretrieve')
autosend = engine.get_config('autosend')
self.tracker_enabled.setChecked(engine.get_config('tracker_enabled'))
self.tracker_type.setCurrentIndex(max(0, tracker_type))
self.tracker_interval.setValue(engine.get_config('tracker_interval'))
self.tracker_process.setText(engine.get_config('tracker_process'))
self.tracker_update_wait.setValue(engine.get_config('tracker_update_wait_s'))
self.tracker_update_close.setChecked(engine.get_config('tracker_update_close'))
self.tracker_update_prompt.setChecked(engine.get_config('tracker_update_prompt'))
self.tracker_not_found_prompt.setChecked(engine.get_config('tracker_not_found_prompt'))
self.player.setText(engine.get_config('player'))
self.library_autoscan.setChecked(engine.get_config('library_autoscan'))
self.scan_whole_list.setChecked(engine.get_config('scan_whole_list'))
self.library_full_path.setChecked(engine.get_config('library_full_path'))
self.plex_host.setText(engine.get_config('plex_host'))
self.plex_port.setText(engine.get_config('plex_port'))
self.plex_obey_wait.setChecked(engine.get_config('plex_obey_update_wait_s'))
self.plex_user.setText(engine.get_config('plex_user'))
self.plex_passw.setText(engine.get_config('plex_passwd'))
for path in engine.get_config('searchdir'):
self._add_dir(path)
if autoretrieve == 'always':
self.autoretrieve_always.setChecked(True)
elif autoretrieve == 'days':
self.autoretrieve_days.setChecked(True)
else:
self.autoretrieve_off.setChecked(True)
self.autoretrieve_days_n.setValue(engine.get_config('autoretrieve_days'))
if autosend == 'always':
self.autosend_always.setChecked(True)
elif autosend in ('minutes', 'hours'):
self.autosend_minutes.setChecked(True)
elif autosend == 'size':
self.autosend_size.setChecked(True)
else:
self.autosend_off.setChecked(True)
self.autosend_minutes_n.setValue(engine.get_config('autosend_minutes'))
self.autosend_size_n.setValue(engine.get_config('autosend_size'))
self.autosend_at_exit.setChecked(engine.get_config('autosend_at_exit'))
self.auto_status_change.setChecked(engine.get_config('auto_status_change'))
self.auto_status_change_if_scored.setChecked(engine.get_config('auto_status_change_if_scored'))
self.auto_date_change.setChecked(engine.get_config('auto_date_change'))
self.tray_icon.setChecked(self.config['show_tray'])
self.close_to_tray.setChecked(self.config['close_to_tray'])
self.start_in_tray.setChecked(self.config['start_in_tray'])
self.tray_api_icon.setChecked(self.config['tray_api_icon'])
self.notifications.setChecked(self.config['notifications'])
self.remember_geometry.setChecked(self.config['remember_geometry'])
self.remember_columns.setChecked(self.config['remember_columns'])
self.columns_per_api.setChecked(self.config['columns_per_api'])
self.filter_bar_position.setCurrentIndex(self.filter_bar_position.findData(self.config['filter_bar_position']))
self.inline_edit.setChecked(self.config['inline_edit'])
self.ep_bar_style.setCurrentIndex(self.ep_bar_style.findData(self.config['episodebar_style']))
self.ep_bar_text.setChecked(self.config['episodebar_text'])
self.autoretrieve_days_n.setEnabled(self.autoretrieve_days.isChecked())
self.autosend_minutes_n.setEnabled(self.autosend_minutes.isChecked())
self.autosend_size_n.setEnabled(self.autosend_size.isChecked())
self.close_to_tray.setEnabled(self.tray_icon.isChecked())
self.start_in_tray.setEnabled(self.tray_icon.isChecked())
self.notifications.setEnabled(self.tray_icon.isChecked())
self.color_values = self.config['colors'].copy()
self.tracker_type_change(None)
def _save(self):
engine = self.worker.engine
engine.set_config('tracker_enabled', self.tracker_enabled.isChecked())
engine.set_config('tracker_type', self.tracker_type.itemData(self.tracker_type.currentIndex()))
engine.set_config('tracker_interval', self.tracker_interval.value())
engine.set_config('tracker_process', str(self.tracker_process.text()))
engine.set_config('tracker_update_wait_s', self.tracker_update_wait.value())
engine.set_config('tracker_update_close', self.tracker_update_close.isChecked())
engine.set_config('tracker_update_prompt', self.tracker_update_prompt.isChecked())
engine.set_config('tracker_not_found_prompt', self.tracker_not_found_prompt.isChecked())
engine.set_config('player', self.player.text())
engine.set_config('library_autoscan', self.library_autoscan.isChecked())
engine.set_config('scan_whole_list', self.scan_whole_list.isChecked())
engine.set_config('library_full_path', self.library_full_path.isChecked())
engine.set_config('plex_host', self.plex_host.text())
engine.set_config('plex_port', self.plex_port.text())
engine.set_config('plex_obey_update_wait_s', self.plex_obey_wait.isChecked())
engine.set_config('plex_user', self.plex_user.text())
engine.set_config('plex_passwd', self.plex_passw.text())
engine.set_config('searchdir', [self.searchdirs.item(i).text() for i in range(self.searchdirs.count())])
if self.autoretrieve_always.isChecked():
engine.set_config('autoretrieve', 'always')
elif self.autoretrieve_days.isChecked():
engine.set_config('autoretrieve', 'days')
else:
engine.set_config('autoretrieve', 'off')
engine.set_config('autoretrieve_days', self.autoretrieve_days_n.value())
if self.autosend_always.isChecked():
engine.set_config('autosend', 'always')
elif self.autosend_minutes.isChecked():
engine.set_config('autosend', 'minutes')
elif self.autosend_size.isChecked():
engine.set_config('autosend', 'size')
else:
engine.set_config('autosend', 'off')
engine.set_config('autosend_minutes', self.autosend_minutes_n.value())
engine.set_config('autosend_size', self.autosend_size_n.value())
engine.set_config('autosend_at_exit', self.autosend_at_exit.isChecked())
engine.set_config('auto_status_change', self.auto_status_change.isChecked())
engine.set_config('auto_status_change_if_scored', self.auto_status_change_if_scored.isChecked())
engine.set_config('auto_date_change', self.auto_date_change.isChecked())
engine.save_config()
self.config['show_tray'] = self.tray_icon.isChecked()
self.config['close_to_tray'] = self.close_to_tray.isChecked()
self.config['start_in_tray'] = self.start_in_tray.isChecked()
self.config['tray_api_icon'] = self.tray_api_icon.isChecked()
self.config['notifications'] = self.notifications.isChecked()
self.config['remember_geometry'] = self.remember_geometry.isChecked()
self.config['remember_columns'] = self.remember_columns.isChecked()
self.config['columns_per_api'] = self.columns_per_api.isChecked()
self.config['filter_bar_position'] = self.filter_bar_position.itemData(self.filter_bar_position.currentIndex())
self.config['inline_edit'] = self.inline_edit.isChecked()
self.config['episodebar_style'] = self.ep_bar_style.itemData(self.ep_bar_style.currentIndex())
self.config['episodebar_text'] = self.ep_bar_text.isChecked()
self.config['colors'] = self.color_values
utils.save_config(self.config, self.configfile)
self.saved.emit()
def s_save(self):
self._save()
self.accept()
def tracker_type_change(self, checked):
if self.tracker_enabled.isChecked():
self.tracker_interval.setEnabled(True)
self.tracker_update_wait.setEnabled(True)
self.tracker_type.setEnabled(True)
if self.tracker_type.itemData(self.tracker_type.currentIndex()) == 'plex':
self.plex_host.setEnabled(True)
self.plex_port.setEnabled(True)
self.plex_obey_wait.setEnabled(True)
self.plex_user.setEnabled(True)
self.plex_passw.setEnabled(True)
self.tracker_process.setEnabled(False)
else:
self.tracker_process.setEnabled(True)
self.plex_host.setEnabled(False)
self.plex_port.setEnabled(False)
self.plex_user.setEnabled(False)
self.plex_passw.setEnabled(False)
self.plex_obey_wait.setEnabled(False)
else:
self.tracker_type.setEnabled(False)
self.plex_host.setEnabled(False)
self.plex_port.setEnabled(False)
self.plex_user.setEnabled(False)
self.plex_passw.setEnabled(False)
self.plex_obey_wait.setEnabled(False)
self.tracker_process.setEnabled(False)
self.tracker_interval.setEnabled(False)
self.tracker_update_wait.setEnabled(False)
def s_autoretrieve_days(self, checked):
self.autoretrieve_days_n.setEnabled(checked)
def s_autosend_minutes(self, checked):
self.autosend_minutes_n.setEnabled(checked)
def s_autosend_size(self, checked):
self.autosend_size_n.setEnabled(checked)
def s_tray_icon(self, checked):
self.close_to_tray.setEnabled(checked)
self.start_in_tray.setEnabled(checked)
self.tray_api_icon.setEnabled(checked)
self.notifications.setEnabled(checked)
def s_ep_bar_style(self, index):
if self.ep_bar_style.itemData(index) == ShowsTableDelegate.BarStyle04:
self.ep_bar_text.setEnabled(False)
else:
self.ep_bar_text.setEnabled(True)
def s_auto_status_change(self, checked):
self.auto_status_change_if_scored.setEnabled(checked)
def s_player_browse(self):
if pyqt_version is 5:
self.player.setText(QFileDialog.getOpenFileName(caption='Choose player executable')[0])
else:
self.player.setText(QFileDialog.getOpenFileName(caption='Choose player executable'))
def s_searchdirs_add(self):
self._add_dir(QFileDialog.getExistingDirectory(caption='Choose media directory'))
def s_searchdirs_remove(self):
row = self.searchdirs.currentRow()
if row != -1:
self.searchdirs.takeItem(row)
def s_switch_page(self, new, old):
if not new:
new = old
self.contents.setCurrentIndex(self.category_list.row(new))
def s_color_picker(self, key, system):
return lambda: self.color_picker(key, system)
def color_picker(self, key, system):
if system is True:
current = self.color_values[key]
result = ThemedColorPicker.do()
if result is not None and result is not current:
self.color_values[key] = result
self.update_colors()
else:
current = getColor(self.color_values[key])
result = QColorDialog.getColor(current)
if result.isValid() and result is not current:
self.color_values[key] = str(result.name())
self.update_colors()
def update_colors(self):
for ((key, label), color) in zip(self.colors['rows']+self.colors['progress'], self.color_buttons):
color.setStyleSheet('background-color: ' + getColor(self.color_values[key]).name())
class ExecStack(ElementMaster):
pixmap_path = 'images/ExecStack.png'
child_pos = (True, False)
update_stack = pyqtSignal(str, name='update_stack')
def __init__(self, row, column):
self.row = row
self.column = column
self.show_window = False
# filename, rel_path, read_mode, write_mode, b_array_limits, n_array_limits, log_state
filename = None
rel_path = False
read_mode = 0
write_mode = 0
delete_read = False
b_array_limits = False
n_array_limits = None
log_state = False
self.config = (filename, rel_path, read_mode, write_mode, delete_read,
b_array_limits, n_array_limits, log_state)
super().__init__(self.row, self.column, self.pixmap_path, True, self.config)
super().edit_sig.connect(self.edit)
logging.debug('ExecStack called at row {}, column {}'.format(row, column))
self.addFunction(StackFunction)
def __setstate__(self, state):
logging.debug('__setstate__() called ExecStack')
self.row, self.column, self.config = state
super().__init__(self.row, self.column, self.pixmap_path, True, self.config)
super().edit_sig.connect(self.edit)
self.addFunction(StackFunction)
def __getstate__(self):
logging.debug('__getstate__() called ExecStack')
return (self.row, self.column, self.config)
def openEditor(self):
logging.debug('openEditor() called ExecStack')
def toggle_debug(self):
logging.debug('ExecStack::toggle_debug() called OVERWRITTEN method')
self.stackWindow = StackWindow(self)
# diable debug button
self.icon_bar.debug_button.debug_pressed.disconnect()
self.icon_bar.debug_button.disableMouseEvent()
# enable debug button when window is closed
self.stackWindow.closed.connect(self.reconnect_debug_button)
self.stackWindow.closed.connect(self.icon_bar.debug_button.enableMouseEvent)
# connect the update signal
self.update_stack.connect(self.stackWindow.updateStack)
# pass filename to the window
filename = self.config[0]
rel_path = self.config[1]
if rel_path and filename:
filepath = os.path.join(os.environ['HOME'], filename)
else:
filepath = filename
self.stackWindow.raiseWindow(filepath)
def reconnect_debug_button(self):
self.icon_bar.debug_button.debug_pressed.connect(
self.icon_bar.click_debug_element)
def highlightStop(self):
logging.debug('ExecStack::highlightStop() called OVERWRITTEN method')
# pass filename
filename = self.config[0]
rel_path = self.config[1]
if rel_path and filename:
filepath = os.path.join(os.environ['HOME'], filename)
else:
filepath = filename
self.update_stack.emit(filepath)
super().highlightStop()
def edit(self):
logging.debug('edit() called ExecStack')
# filename, rel_path, read_mode, write_mode, array_limits, log_state
self.filename, self.rel_path, self.read_mode, self.write_mode, self.delete_read, \
self.b_array_limits, self.n_array_limits, log_state = self.config
self.returnEditLayout = QVBoxLayout()
self.returnEdit = ElementEditor(self)
self.returnEdit.setWindowTitle(QC.translate('', 'Stack'))
self.top_text = QLabel()
self.top_text.setText(QC.translate('', 'Choose file on hard disc for storing stack data:'))
self.filename_text = QLabel()
self.filename_text.setWordWrap(True)
self.file_button = QPushButton(QC.translate('', 'Select model output file'))
self.file_button.clicked.connect(self.ChooseFileDialog)
self.relative_file_check = QWidget()
self.relative_file_check_layout = QHBoxLayout(self.relative_file_check)
self.relative_file_label = QLabel()
self.relative_file_label.setText(QC.translate('', 'Filename relative to $HOME.'))
self.relative_file_checkbox = QCheckBox()
self.relative_file_check_layout.addWidget(self.relative_file_checkbox)
self.relative_file_check_layout.addWidget(self.relative_file_label)
self.relative_file_check_layout.addStretch(1)
self.relative_filepath_input = QLineEdit()
self.relative_filepath_input.setPlaceholderText('my_folder/my_file')
self.file_input = QWidget()
self.file_input_layout = QVBoxLayout(self.file_input)
self.file_input_layout.addWidget(self.filename_text)
self.file_input_layout.addWidget(self.file_button)
self.file_input_layout.addWidget(self.relative_file_check)
self.file_input_layout.addWidget(self.relative_filepath_input)
self.writeInput()
self.readOutput()
self.loadLastConfig()
self.mode_text = QLabel()
self.mode_text.setText(QC.translate('', 'Configuration:'))
self.help_text = QWidget()
self.help_text_layout = QVBoxLayout(self.help_text)
#self.help_text_1 = QLabel()
# List
#self.help_text_1.setText(QC.translate('', 'On input: Write / Read'))
# Input: Liste
#self.help_text_2 = QLabel()
#self.help_text_2.setText(QC.translate('', 'Insert /Append'))
# Option: Remove output
# Output: Liste: First Out / Last Out / all Out
#self.help_text_3 = QLabel()
#self.help_text_3.setText(QC.translate('', 'Help Text 3'))
#self.help_text_layout.addWidget(self.help_text_1)
#self.help_text_layout.addWidget(self.help_text_2)
#self.help_text_layout.addWidget(self.help_text_3)
self.confirm_button = QPushButton(QC.translate('', 'Ok'))
# hier logging option einfügen
self.log_line = QWidget()
self.ask_for_logging = QLabel()
self.ask_for_logging.setText(QC.translate('', 'Log output?'))
self.log_checkbox = QCheckBox()
self.log_line_layout = QHBoxLayout(self.log_line)
self.log_line_layout.addWidget(self.ask_for_logging)
self.log_line_layout.addWidget(self.log_checkbox)
self.log_line_layout.addStretch(1)
self.log_checkbox.setChecked(log_state)
#signals and slots
self.confirm_button.clicked.connect(self.returnEdit.closeEvent)
self.returnEdit.window_closed.connect(self.edit_done)
self.relative_file_checkbox.stateChanged.connect(self.toggleFileInput)
self.returnEditLayout.addWidget(self.top_text)
self.returnEditLayout.addWidget(self.file_input)
self.returnEditLayout.addWidget(self.mode_text)
self.returnEditLayout.addWidget(self.write_input)
self.returnEditLayout.addWidget(self.read_input)
self.returnEditLayout.addWidget(self.delete_read_widget)
#self.returnEditLayout.addWidget(self.help_text)
self.returnEditLayout.addStretch(1)
self.returnEditLayout.addWidget(self.log_line)
self.returnEditLayout.addWidget(self.confirm_button)
self.returnEdit.setLayout(self.returnEditLayout)
self.returnEdit.show()
def loadLastConfig(self):
self.select_read_mode.setCurrentIndex(self.read_mode)
self.select_write_mode.setCurrentIndex(self.write_mode)
self.relative_file_checkbox.setChecked(self.rel_path)
if self.b_array_limits:
self.enableArrLimits()
self.array_limits_cbox.setChecked(True)
if self.n_array_limits:
self.max_array_elements.setText(str(self.n_array_limits))
else:
self.diableArrLimits()
self.array_limits_cbox.setChecked(False)
if self.delete_read:
self.delete_read_checkbox.setChecked(True)
else:
self.delete_read_checkbox.setChecked(False)
if self.rel_path:
self.toggleFileInput(2)
if self.filename:
self.relative_filepath_input.setText(self.filename)
else:
self.toggleFileInput(0)
if self.filename:
self.filename_text.setText(self.filename)
def toggleFileInput(self, event):
logging.debug('ExecStack::toggleFileInput() called: {}'.format(event))
# 0 = FALSE, 2 = TRUE
if event: # TRUE
self.file_button.setDisabled(True)
self.relative_filepath_input.setDisabled(False)
self.filename_text.setText('')
else:
self.file_button.setDisabled(False)
self.relative_filepath_input.clear()
self.relative_filepath_input.setDisabled(True)
self.relative_filepath_input.setPlaceholderText('my_folder/my_file')
def ChooseFileDialog(self, event):
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
fileName, _ = QFileDialog.getSaveFileName(self, \
QC.translate('', 'Choose file'),"","All Files (*);;Text Files (*.txt)", \
options=options)
if fileName:
logging.debug('ExecStack::ChooseFileDialog() called with filename: {}'.format(fileName))
self.filename = fileName
self.filename_text.setText(self.filename)
def writeInput(self):
self.write_input = QWidget()
self.write_layout = QVBoxLayout(self.write_input)
self.write_input_line = QWidget()
self.write_input_layout = QHBoxLayout(self.write_input_line)
self.array_config = QWidget()
self.array_config_layout = QHBoxLayout(self.array_config)
self.outpub_behaviour = QWidget()
self.output_behaviour_layout = QHBoxLayout()
self.write_txt = QLabel()
self.write_txt.setText(QC.translate('', 'Do this with input:'))
self.select_write_mode = QComboBox()
self.select_write_mode.addItem(QC.translate('', 'Nothing'), QVariant('none'))
self.select_write_mode.addItem(QC.translate('', 'Insert'), QVariant('i'))
self.select_write_mode.addItem(QC.translate('', 'Append'), QVariant('a'))
# maximum array size
self.array_limits_cbox = QCheckBox()
self.array_limits_cbox.stateChanged.connect(self.toggleArrayLimits)
self.array_limit_txt = QLabel()
self.array_limit_txt.setText(QC.translate('', 'Max. array elements:'))
self.max_array_elements = QLineEdit()
self.max_array_elements.setValidator(QIntValidator(1, 999))
self.max_array_elements.setPlaceholderText(QC.translate('', 'Default value: 20'))
self.array_config_layout.addWidget(self.array_limits_cbox)
self.array_config_layout.addWidget(self.array_limit_txt)
self.array_config_layout.addWidget(self.max_array_elements)
self.write_input_layout.addWidget(self.write_txt)
self.write_input_layout.addWidget(self.select_write_mode)
#self.write_layout.addWidget(self.array_limits)
self.write_layout.addWidget(self.write_input_line)
self.write_layout.addWidget(self.array_config)
#self.variable_box.addWidget(self.write_input)
def toggleArrayLimits(self, event):
#einzeln aufrufen beim laden der config
if self.array_limits_cbox.isChecked():
self.enableArrLimits()
else:
self.diableArrLimits()
def toggleReadBehaviour(self, event):
if self.delete_read_checkbox.isChecked():
self.delete_read_checkbox.setChecked(True)
else:
self.delete_read_checkbox.setChecked(False)
def enableArrLimits(self):
self.max_array_elements.setEnabled(True)
self.max_array_elements.setPlaceholderText(QC.translate('', 'Default value: 20'))
def diableArrLimits(self):
self.max_array_elements.setEnabled(False)
self.max_array_elements.setPlaceholderText(QC.translate('', 'Unlimited'))
def readOutput(self):
self.read_input = QWidget()
self.read_layout = QHBoxLayout(self.read_input)
self.delete_read_widget = QWidget()
self.delete_read_layout = QHBoxLayout(self.delete_read_widget)
self.read_txt = QLabel()
self.read_txt.setText(QC.translate('', 'Do this when triggered:'))
self.select_read_mode = QComboBox()
self.select_read_mode.addItem(QC.translate('', 'Nothing'), QVariant('none'))
self.select_read_mode.addItem(QC.translate('', 'Pass through'), QVariant('pass'))
self.select_read_mode.addItem(QC.translate('', 'First out'), QVariant('fo'))
self.select_read_mode.addItem(QC.translate('', 'Last out'), QVariant('lo'))
self.select_read_mode.addItem(QC.translate('', 'All out'), QVariant('all'))
# the delete_read widget is added in the edit() method
self.delete_read_txt = QLabel()
self.delete_read_txt.setText(QC.translate('', 'Delete object after read?'))
self.delete_read_checkbox = QCheckBox()
self.delete_read_checkbox.stateChanged.connect(self.toggleReadBehaviour)
self.delete_read_layout.addWidget(self.delete_read_txt)
self.delete_read_layout.addWidget(self.delete_read_checkbox)
self.read_layout.addWidget(self.read_txt)
self.read_layout.addWidget(self.select_read_mode)
def edit_done(self):
logging.debug('edit_done() called ExecStack' )
if self.max_array_elements.text() == '':
n_array_limits = None
else:
n_array_limits = int(self.max_array_elements.text())
log_state = self.log_checkbox.isChecked()
write_mode = self.select_write_mode.currentIndex()
read_mode = self.select_read_mode.currentIndex()
b_array_limits = self.array_limits_cbox.isChecked()
delete_read = self.delete_read_checkbox.isChecked()
n_array_limits
filename = self.filename
rel_path = self.relative_file_checkbox.isChecked()
if rel_path:
filename = self.relative_filepath_input.text()
else:
filename = self.filename
if filename == '':
filename = None
# filename, read_mode, write_mode, b_array_limits, n_array_limits, log_state
self.config = (filename, rel_path, read_mode, write_mode, delete_read, b_array_limits, \
n_array_limits, log_state)
self.addFunction(StackFunction)
class ModeShiftDialog(QDialog):
def __init__(self, parent=None):
super(ModeShiftDialog, self).__init__(parent)
mainLayout = QGridLayout()
self.setLayout(mainLayout)
self.keyLabel = QLabel()
self.keyInput = QLineEdit()
self.modeCombo = QComboBox()
self.modeLabel = QLabel()
self.buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
userguide.addButton(self.buttons, "mode_shift")
for m in sorted(modes.keys()):
self.modeCombo.addItem(m)
mainLayout.addWidget(self.keyLabel, 0, 0, 1, 1)
mainLayout.addWidget(self.keyInput, 0, 1, 1, 1)
mainLayout.addWidget(self.modeLabel, 1, 0, 1, 1)
mainLayout.addWidget(self.modeCombo, 1, 1, 1, 1)
mainLayout.addWidget(self.buttons, 9, 0, 2, 2)
app.translateUI(self)
qutil.saveDialogSize(self, "mode_shift/dialog/size", QSize(80, 60))
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
self.keyInput.textEdited.connect(self.readKeyInput)
self.modeCombo.currentIndexChanged.connect(self.readSettings)
self.loadSettings()
def translateUI(self):
self.setWindowTitle(app.caption(_("Mode Shift")))
self.keyLabel.setText(_("Key:"))
self.modeLabel.setText(_("Mode:"))
self.buttons.button(QDialogButtonBox.Ok).setText(_("shift pitches"))
self.buttons.button(QDialogButtonBox.Ok).setEnabled(False)
def setKeyValidator(self, validate):
"""Set function that validates the key input."""
keyValidator = KeyValidator()
keyValidator.setValidateFunc(validate)
self.keyInput.setValidator(keyValidator)
def readSettings(self):
"""Reads the current settings."""
self._currentKey = self.keyInput.text()
self._currentMode = self.modeCombo.currentText()
def readKeyInput(self):
"""Read the key input and check if it's acceptable."""
if self.keyInput.hasAcceptableInput():
self.readSettings()
self.buttons.button(QDialogButtonBox.Ok).setEnabled(True)
else:
self.buttons.button(QDialogButtonBox.Ok).setEnabled(False)
def getMode(self):
"""Returns the chosen mode."""
return self._currentKey, modes[self._currentMode]
def loadSettings(self):
""" get users previous settings """
s = QSettings()
s.beginGroup('mode_shift')
key = s.value('key', "", str)
self.keyInput.setText(key)
index = s.value('mode', 0, int)
self.modeCombo.setCurrentIndex(index)
self.readKeyInput()
def saveSettings(self):
""" save users last settings """
s = QSettings()
s.beginGroup('mode_shift')
s.setValue('key', self._currentKey)
s.setValue('mode', self.modeCombo.currentIndex())
class ExampleWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
# set default values
self.save_image_enable = False
self.raw_image = []
self.auto_mode_enable = False
self.shot_emulate = False
self.RASPI_IP = "192.168.0.101"
self.RASPI_PORT = 65432
self.RASPI_BUF = 10
self.STEPPER_CONST = 6.6666666
self.TEMPLATE_SIZE = 60
self.stepper_x = 0
self.stepper_y = 0
self.camera_enabled = False
self.find_disks_enabled = False
self.disk_locations = []
self.goal_loc = (300, 300)
self.target_disk_loc = (150, 150)
self.laser_loc = (100, 100) # default value
self.desired_laser_coord = (0, 0)
self.find_disks_roi_enabled = False
self.gray = []
self.template_image = []
self.original_template_image = []
self.pulse_number = 0
self.pulse_on = 0
self.pulse_off = 0
# Set validators
self.onlyInt = QIntValidator()
self.onlyDbl = QDoubleValidator()
# set window properties
centralWidget = QWidget(self)
self.setMinimumSize(QSize(1600, 950))
self.setWindowTitle("Gelbot aimbot")
self.setCentralWidget(centralWidget)
# Create combobox and add items.
self.cameraComboBox = QComboBox(centralWidget)
self.cameraComboBox.setGeometry(QRect(70, 45, 40, 20))
self.cameraComboBox.setObjectName(("cameraComboBox"))
self.refresh_camera_list()
self.cameraComboBox.currentIndexChanged.connect(self.camera_changed)
# Create camera combo box label
self.cameraLabel = QLabel(centralWidget)
self.cameraLabel.setGeometry(QRect(10, 40, 80, 31))
self.cameraLabel.setText("Camera:")
# Create width label
self.widthLabel = QLabel(centralWidget)
self.widthLabel.setGeometry(QRect(130, 40, 80, 31))
self.widthLabel.setText("Width:")
# Create width input box
self.widthInput = QLineEdit(centralWidget)
self.widthInput.move(180, 41)
self.widthInput.setFixedWidth(40)
self.widthInput.setValidator(self.onlyInt)
self.widthInput.editingFinished.connect(self.width_edited)
# Create height label
self.heightLabel = QLabel(centralWidget)
self.heightLabel.setGeometry(QRect(230, 40, 80, 31))
self.heightLabel.setText("Height:")
# Create height input box
self.heightInput = QLineEdit(centralWidget)
self.heightInput.move(280, 41)
self.heightInput.setFixedWidth(40)
self.heightInput.setValidator(self.onlyInt)
self.heightInput.editingFinished.connect(self.height_edited)
# Create FPS label
self.fpsLabel = QLabel(centralWidget)
self.fpsLabel.setGeometry(QRect(330, 40, 80, 31))
self.fpsLabel.setText("FPS:")
# Create fps input box
self.fpsInput = QLineEdit(centralWidget)
self.fpsInput.move(380, 41)
self.fpsInput.setFixedWidth(40)
self.fpsInput.setValidator(self.onlyInt)
self.fpsInput.editingFinished.connect(self.fps_edited)
# Create exposure label
self.exposureLabel = QLabel(centralWidget)
self.exposureLabel.setGeometry(QRect(430, 40, 80, 31))
self.exposureLabel.setText("Exposure:")
# Create fps input box
self.exposureInput = QLineEdit(centralWidget)
self.exposureInput.move(500, 41)
self.exposureInput.setFixedWidth(40)
self.exposureInput.setValidator(self.onlyInt)
self.exposureInput.editingFinished.connect(self.exposure_edited)
# Create gain label
self.gainLabel = QLabel(centralWidget)
self.gainLabel.setGeometry(QRect(800, 40, 80, 31))
self.gainLabel.setText("Gain:")
# Create gain input box
self.gainInput = QLineEdit(centralWidget)
self.gainInput.move(840, 41)
self.gainInput.setFixedWidth(40)
self.gainInput.setValidator(self.onlyDbl)
self.gainInput.editingFinished.connect(self.gain_edited)
# Create brightness label
self.brightnessLabel = QLabel(centralWidget)
self.brightnessLabel.setGeometry(QRect(900, 40, 80, 31))
self.brightnessLabel.setText("Brightness:")
# Create gain input box
self.brightnessInput = QLineEdit(centralWidget)
self.brightnessInput.move(980, 41)
self.brightnessInput.setFixedWidth(40)
self.brightnessInput.setValidator(self.onlyDbl)
self.brightnessInput.editingFinished.connect(self.brightness_edited)
# Create pulse number label
self.pulseNumberLabel = QLabel(centralWidget)
self.pulseNumberLabel.setGeometry(QRect(330, 0, 80, 31))
self.pulseNumberLabel.setText("Pulse n.:")
# Create pulse number input box
self.pulseNumberInput = QLineEdit(centralWidget)
self.pulseNumberInput.move(400, 0)
self.pulseNumberInput.setFixedWidth(40)
self.pulseNumberInput.setValidator(self.onlyInt)
self.pulseNumberInput.editingFinished.connect(self.pulse_number_edited)
# Create laser on label
self.laserOnLabel = QLabel(centralWidget)
self.laserOnLabel.setGeometry(QRect(500, 0, 80, 31))
self.laserOnLabel.setText("On.:")
# Create laser on input box
self.laserOnInput = QLineEdit(centralWidget)
self.laserOnInput.move(600, 0)
self.laserOnInput.setFixedWidth(40)
self.laserOnInput.setValidator(self.onlyInt)
self.laserOnInput.editingFinished.connect(self.laser_on_edited)
# Create laser on label
self.laserOffLabel = QLabel(centralWidget)
self.laserOffLabel.setGeometry(QRect(700, 0, 80, 31))
self.laserOffLabel.setText("Off.:")
# Create laser on input box
self.laserOffInput = QLineEdit(centralWidget)
self.laserOffInput.move(800, 0)
self.laserOffInput.setFixedWidth(40)
self.laserOffInput.setValidator(self.onlyInt)
self.laserOffInput.editingFinished.connect(self.laser_off_edited)
# add pix
self.imageDisplay = QLabel(self)
self.imageDisplay.setGeometry(QRect(10, 80, 1200, 800))
self.imageDisplay.setPixmap(QPixmap("Disk0001.tiff"))
self.imageDisplay.show()
# add pix with found disks
self.disksDisplay = QLabel(self)
self.disksDisplay.setGeometry(QRect(1230, 80, 600, 480))
self.disksDisplay.setPixmap(
QPixmap("response2020-01-28 15:08:11.933959.png"))
self.disksDisplay.show()
# run camera button
self.runCameraButton = QPushButton('Run camera', self)
self.runCameraButton.setToolTip('This is an example button')
self.runCameraButton.move(600, 40)
self.runCameraButton.clicked.connect(self.run_camera)
# save disk centers button
self.saveButton = QPushButton('Save img', self)
self.saveButton.setToolTip('Save imige with disk centers')
self.saveButton.move(1750, 40)
self.saveButton.clicked.connect(self.save_disk_enabler)
self.timerShowImage = QtCore.QTimer(self)
self.timerShowImage.timeout.connect(self.show_image)
self.timerShowImage.start(10) # 10 Hz
self.timerSaveImage = QtCore.QTimer(self)
self.timerSaveImage.timeout.connect(self.save_disks)
self.timerSaveImage.start(500) # 10 Hz
self.timerAuto = QtCore.QTimer(self)
self.timerAuto.timeout.connect(self.auto_mode)
#self.timerAuto.stop()
# Create log
self.logger = QtWidgets.QPlainTextEdit(centralWidget)
self.logger.setGeometry(10, 900, 1000, 40)
self.logger.setReadOnly(True)
self.logger.setPlainText("Initialized..")
# Create combobox for camera resolution and add items.
self.resolutionComboBox = QComboBox(centralWidget)
self.resolutionComboBox.setGeometry(QRect(1100, 40, 200, 31))
self.resolutionComboBox.setObjectName(("resolutionComboBox"))
self.resolutionComboBox.addItem("800 x 600")
self.resolutionComboBox.addItem("1920 x 1080")
self.resolutionComboBox.currentIndexChanged.connect(
self.resolution_changed)
# find disks button
self.findDisksButton = QPushButton('Find disks', self)
self.findDisksButton.setToolTip('Click to find disks')
self.findDisksButton.move(1350, 40)
self.findDisksButton.clicked.connect(self.find_disks)
# estimate steps button
self.computeStepsButton = QPushButton('Steps', self)
self.computeStepsButton.setToolTip('Click to compute steps')
self.computeStepsButton.move(1350, 600)
self.computeStepsButton.clicked.connect(self.get_steps)
# recompute goal button
self.recomputeGoalButton = QPushButton('New goal', self)
self.recomputeGoalButton.setToolTip('Click to recompute goal coord')
self.recomputeGoalButton.move(1450, 600)
self.recomputeGoalButton.clicked.connect(self.recompute_goal)
#SETTERS
# set laser button
self.setLaserButton = QPushButton('Laser', self)
self.setLaserButton.setToolTip('Click to set laser location')
self.setLaserButton.move(1450, 40)
self.setLaserButton.clicked.connect(self.set_laser_loc)
# Create laser coordinatex input box
self.laserCoordInput = QLineEdit(centralWidget)
self.laserCoordInput.move(1450, 10)
self.laserCoordInput.setFixedWidth(100)
# Create goal coordinatex input box
self.goalCoordInput = QLineEdit(centralWidget)
self.goalCoordInput.move(1550, 10)
self.goalCoordInput.setFixedWidth(100)
# Create disk coordinate input box
self.diskCoordInput = QLineEdit(centralWidget)
self.diskCoordInput.move(1650, 10)
self.diskCoordInput.setFixedWidth(100)
# set goal button
self.setGoalButton = QPushButton('Goal', self)
self.setGoalButton.setToolTip('Click to set goal location')
self.setGoalButton.move(1550, 40)
self.setGoalButton.clicked.connect(self.set_goal_loc)
# set target disk button
self.setDiskButton = QPushButton('Disk', self)
self.setDiskButton.setToolTip('Click to set goal location')
self.setDiskButton.move(1650, 40)
self.setDiskButton.clicked.connect(self.set_target_disk_loc)
# get template button
self.getTemplateButton = QPushButton('Template', self)
self.getTemplateButton.setToolTip('Click capture templates')
self.getTemplateButton.move(1650, 600)
self.getTemplateButton.clicked.connect(self.get_template)
# auto button
self.autoButton = QPushButton('Auto', self)
self.autoButton.setToolTip('Automatic mode')
self.autoButton.move(1650, 800)
self.autoButton.clicked.connect(self.auto_mode_enabler)
# shot emulate button
self.shotButton = QPushButton('Shot', self)
self.shotButton.setToolTip('Shot emulate')
self.shotButton.move(1650, 900)
self.shotButton.clicked.connect(self.shot)
# Set camera
self.camera = cv2.VideoCapture(0)
time.sleep(0.1)
self.camera.set(cv2.CAP_PROP_FRAME_WIDTH, 800) # works well
time.sleep(0.1)
self.camera.set(cv2.CAP_PROP_FRAME_HEIGHT, 600) # works well
time.sleep(.2)
# Set laser loc from previous
try:
f = open("../laser_loc.txt", "r")
self.laser_loc = eval(f.readline())
print(self.laser_loc)
self.laserCoordInput.setText(str(self.laser_loc)[1:-1])
except:
pass
self.keyPressEvent = self.keyPressEvent
# open socket for stream
#self.k = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#self.k.connect((self.RASPI_IP, self.RASPI_PORT))
# Set key press events
def keyPressEvent(self, e):
print(e.key())
self.logger.setPlainText("event " + str(e.key()))
if e.key() == 65:
# move left
self.move_stepper("x-10")
# try:
# self.k.sendalla(bytes("x-10", "UTF-8"))
# except:
# print("dont care about boken pipe shit")
elif e.key() == 68:
# move right
self.move_stepper("x10")
elif e.key() == 83:
# move top
self.move_stepper("y10")
elif e.key() == 87:
# move down
self.move_stepper("y-10")
elif e.key() == 81:
self.move_stepper("s")
elif e.key() == 69:
self.move_stepper("l")
def shot(self):
print("I SHOT!!!!!!!!!!")
for i in range(self.pulse_number):
print("shot n.: ", i)
print(self.pulse_on / 1000)
self.move_stepper("s")
time.sleep(self.pulse_on / 1000)
self.move_stepper("l")
time.sleep(self.pulse_off / 1000)
pass
print("shooting done")
self.shot_emulate = True
def auto_mode(self):
print("f*****g auto ", datetime.datetime.now())
if self.shot_emulate:
self.shot_emulate = False
self.find_disks_enabled = True
self.show_image()
self.get_steps()
self.show_image()
self.shot()
def auto_mode_enabler(self):
if self.timerAuto.isActive():
self.timerAuto.stop()
else:
self.timerAuto.start(1000)
self.shot_emulate = True
def get_disk_template(self, event, x, y, flags, param):
pass
# grab references to the global variables
# performed
if event == cv2.EVENT_LBUTTONDOWN:
self.template_image = copy.deepcopy(self.original_template_image)
template_to_save = self.original_template_image[y:y +
self.TEMPLATE_SIZE,
x:x +
self.TEMPLATE_SIZE]
template_to_save = cv2.cvtColor(template_to_save,
cv2.COLOR_BGR2GRAY)
cv2.imwrite(
os.path.join("disk_templates",
str(datetime.datetime.now()) + ".png"),
template_to_save)
if event == cv2.EVENT_MOUSEMOVE:
self.template_image = copy.deepcopy(self.original_template_image)
cv2.rectangle(self.template_image, (x, y),
(x + self.TEMPLATE_SIZE, y + self.TEMPLATE_SIZE),
(0, 255, 255))
def get_template(self):
self.template_image = cv2_worker.get_image(self.camera)
self.original_template_image = self.template_image
cv2.namedWindow("template win")
cv2.setMouseCallback("template win", self.get_disk_template)
while True:
# display the image and wait for a keypress
cv2.imshow("template win", self.template_image)
key = cv2.waitKey(1) & 0xFF
# if the 'c' key is pressed, break from the loop
if key == ord("c"):
cv2.destroyAllWindows()
break
def save_disks(self):
#print(type(self.gray))
#print(self.gray)
if self.save_image_enable:
cv2.imwrite(
os.path.join(
"25022020",
"response" + str(datetime.datetime.now()) + ".png"),
self.raw_image)
def save_disk_enabler(self):
self.save_image_enable = not self.save_image_enable
def pulse_number_edited(self):
#TODO exception
try:
self.pulse_number = int(self.pulseNumberInput.text())
except Exception as e:
print(e)
def laser_on_edited(self):
# TODO exception
try:
self.pulse_on = int(self.laserOnInput.text())
except Exception as e:
print(e)
def laser_off_edited(self):
# TODO exception
try:
self.pulse_off = int(self.laserOffInput.text())
except Exception as e:
print(e)
def recompute_target_coord(self):
max_distance = 999999
print("okokokokok>", self.target_disk_loc)
new_target_loc = self.target_disk_loc
self.target_disk_loc = (
int(
round(self.target_disk_loc[0] -
self.stepper_x / self.STEPPER_CONST)),
int(
round(self.target_disk_loc[1] -
self.stepper_y / self.STEPPER_CONST)))
print("WTFWTFWTFWTFWTF ", new_target_loc)
for disk in self.disk_locations:
distance = np.linalg.norm(
np.asarray(disk) - np.asarray(self.target_disk_loc))
if distance < max_distance:
max_distance = distance
new_target_loc = disk
self.target_disk_loc = new_target_loc
def move_stepper(self, steps):
k = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
k.connect((self.RASPI_IP, self.RASPI_PORT))
k.sendall(bytes(steps, "UTF-8"))
k.close()
def recompute_goal(self):
self.goal_loc = (int(
round(self.goal_loc[0] - self.stepper_x / self.STEPPER_CONST)),
int(
round(self.goal_loc[1] -
self.stepper_y / self.STEPPER_CONST)))
#self.target_disk_loc = (int(round(self.target_disk_loc[0] - self.stepper_x / self.STEPPER_CONST)),
# int(round(self.target_disk_loc[1] - self.stepper_y / self.STEPPER_CONST)))
def get_steps(self):
dx = self.goal_loc[0] - self.target_disk_loc[0]
dy = self.goal_loc[1] - self.target_disk_loc[1]
if abs(dx) < 3:
desired_x = self.target_disk_loc[0]
else:
if dx > 0:
desired_x = self.target_disk_loc[0] - np.sign(dx) * 7
else:
desired_x = self.target_disk_loc[0] - np.sign(dx) * 7
if abs(dy) < 3:
desired_y = self.target_disk_loc[1]
else:
if dy > 0:
desired_y = self.target_disk_loc[1] - np.sign(dy) * 7
else:
desired_y = self.target_disk_loc[1] - np.sign(dy) * 7
self.desired_laser_coord = (desired_x, desired_y)
self.stepper_x = int(
(self.STEPPER_CONST *
(self.desired_laser_coord[0] - self.laser_loc[0])))
self.stepper_y = int(
(self.STEPPER_CONST *
(self.desired_laser_coord[1] - self.laser_loc[1])))
self.logger.setPlainText("Servo steps> x: {}, y: {}".format(
str(self.stepper_x), str(self.stepper_y)))
x_str = "x" + str(self.stepper_x)
y_str = "y" + str(self.stepper_y)
self.move_stepper(x_str)
self.move_stepper(y_str)
time.sleep(1)
self.recompute_goal()
#self.recompute_target_coord()
#self.find_disks_roi_enabled = True
self.find_disks_enabled = True
def set_laser_loc(self):
self.laser_loc = eval(self.laserCoordInput.text())
self.logger.setPlainText("laser loc: {} ".format(str(self.laser_loc)))
f = open("../laser_loc.txt", "w")
f.write(str(self.laser_loc))
f.close()
def set_goal_loc(self):
self.goal_loc = eval(self.goalCoordInput.text())
self.logger.setPlainText("goal loc: {}".format(str(self.goal_loc)))
def set_target_disk_loc(self):
self.target_disk_loc = eval(self.diskCoordInput.text())
self.logger.setPlainText("target disk: {}".format(
self.target_disk_loc))
def width_edited(self):
"""Function to set width of camera image"""
width_value = self.camera.get(cv2.CAP_PROP_FRAME_WIDTH)
try:
new_width_value = int(self.widthInput.text())
self.logger.setPlainText(
"Frame width value changed from {} to {}".format(
str(width_value), str(new_width_value)))
except ValueError:
self.logger.setPlainText("Width value error")
new_width_value = width_value
self.camera.set(cv2.CAP_PROP_FRAME_WIDTH, new_width_value)
time.sleep(1)
def height_edited(self):
"""Function to set height of camera image"""
height_value = self.camera.get(cv2.CAP_PROP_FRAME_HEIGHT)
try:
new_height_value = int(self.heightInput.text())
self.logger.setPlainText(
"Frame height value changed from {} to {}".format(
str(height_value), str(new_height_value)))
except ValueError:
self.logger.setPlainText("Height value error")
new_height_value = height_value
self.camera.set(cv2.CAP_PROP_FRAME_HEIGHT, new_height_value)
time.sleep(1)
def fps_edited(self):
"""Function to set FPS of camera"""
fps_value = self.camera.get(cv2.CAP_PROP_FPS)
camera_id = self.cameraComboBox.currentIndex()
try:
new_fps_value = int(self.fpsInput.text())
self.logger.setPlainText("FPS value changed from {} to {}".format(
str(fps_value), str(new_fps_value)))
except ValueError:
self.logger.setPlainText("FPS value error")
new_fps_value = fps_value
#TODO validate following approach
self.camera.set(cv2.CAP_PROP_FPS, new_fps_value)
subprocess.Popen("v4l2-ctl -d /dev/video{} -p {}".format(
camera_id, new_fps_value),
shell=True)
def exposure_edited(self):
camera_id = self.cameraComboBox.currentIndex()
"""Function to set oxposure of camera"""
# TODO validate following approach
exposure_value = self.camera.get(cv2.CAP_PROP_EXPOSURE)
try:
new_exposure_value = int(self.exposureInput.text())
self.logger.setPlainText(
"Exposure value changed from {} to {}".format(
str(exposure_value), str(new_exposure_value)))
except ValueError:
self.logger.setPlainText("Exposure value error")
new_exposure_value = exposure_value
# subprocess.Popen("v4l2-ctl -d /dev/video{} -c exposure_auto=0".format(camera_id), shell=True)
subprocess.Popen(
"v4l2-ctl -d /dev/video{} -c exposure_absolute={}".format(
camera_id, new_exposure_value),
shell=True)
def gain_edited(self):
camera_id = self.cameraComboBox.currentIndex()
"""Function to set gain of the camera"""
# TODO validate following approach
gain_value = self.camera.get(cv2.CAP_PROP_GAIN)
try:
new_gain_value = float(self.gainInput.text().replace(",", "."))
self.logger.setPlainText("Gain value changed from {} to {}".format(
str(gain_value), str(new_gain_value)))
except ValueError:
self.logger.setPlainText("Gain value error")
new_gain_value = gain_value
self.camera.set(cv2.CAP_PROP_GAIN, new_gain_value)
# subprocess.Popen("v4l2-ctl -d /dev/video{} -c exposure_auto=0".format(camera_id), shell=True)
# subprocess.Popen("v4l2-ctl -d /dev/video{} -c exposure_absolute={}".format(camera_id, new_exposure_value), shell=True)
def brightness_edited(self):
camera_id = self.cameraComboBox.currentIndex()
"""Function to set gain of the camera"""
# TODO validate following approach
brightness_value = self.camera.get(cv2.CAP_PROP_BRIGHTNESS)
try:
new_brightness_value = float(self.brightnessInput.text().replace(
",", "."))
self.logger.setPlainText(
"Brightness value changed from {} to {}".format(
str(brightness_value), str(new_brightness_value)))
except ValueError:
self.logger.setPlainText("Brightness value error")
new_brightness_value = brightness_value
self.camera.set(cv2.CAP_PROP_BRIGHTNESS, new_brightness_value)
def resolution_changed(self):
"""Function to set resolution of camera image"""
new_width_value = self.camera.get(cv2.CAP_PROP_FRAME_WIDTH)
new_height_value = self.camera.get(cv2.CAP_PROP_FRAME_HEIGHT)
chosen_resolution = self.resolutionComboBox.currentText()
print("chosen resolution>", chosen_resolution)
if chosen_resolution == "1920 x 1080":
new_width_value = 1920
new_height_value = 1080
self.laser_loc = (int(self.laser_loc[0] + 640),
int(self.laser_loc[1] + 300))
self.goal_loc = (int(self.goal_loc[0] + 640),
int(self.goal_loc[1] + 300))
self.target_disk_loc = (int(self.target_disk_loc[0] + 640),
int(self.target_disk_loc[1] + 300))
elif chosen_resolution == "800 x 600":
new_width_value = 800
new_height_value = 600
self.laser_loc = (int(self.laser_loc[0] - 640),
int(self.laser_loc[1] - 300))
self.goal_loc = (int(self.goal_loc[0] - 640),
int(self.goal_loc[1] - 300))
self.target_disk_loc = (int(self.target_disk_loc[0] - 640),
int(self.target_disk_loc[1] - 300))
print(new_width_value)
self.camera.set(cv2.CAP_PROP_FRAME_WIDTH, new_width_value)
time.sleep(0.1)
self.camera.set(cv2.CAP_PROP_FRAME_HEIGHT, new_height_value)
time.sleep(0.1)
def get_camera_list(self):
"""Wrapping function to get camera list"""
return cv2_worker.get_available_cameras()
def run_camera(self):
"""Function to enable showing of camera image"""
print("Run camera")
self.camera_enabled = not self.camera_enabled
if self.camera_enabled:
self.runCameraButton.setText("Stop camera")
else:
self.runCameraButton.setText("Run camera")
def refresh_camera_list(self):
"""Function for refreshing cameraComboBox"""
camera_list = self.get_camera_list()
for idx, item in enumerate(camera_list):
self.cameraComboBox.addItem(str(idx))
def show_image(self):
"""Function for showing camera image in the GUI"""
if self.camera_enabled:
new_image = cv2_worker.get_image(self.camera)
self.raw_image = cv2.cvtColor(new_image, cv2.COLOR_BGR2GRAY)
# print(new_image.shape)
i = 0
if self.find_disks_enabled:
print("111111")
gray = cv2.cvtColor(new_image, cv2.COLOR_BGR2GRAY)
self.disk_locations = cv2_worker.find_disks(gray)
print("disks:", self.disk_locations)
for max_loc in self.disk_locations:
print("max loc", max_loc)
gray = cv2.drawMarker(gray,
max_loc, (255, 255, 255),
markerType=cv2.MARKER_CROSS,
markerSize=20,
thickness=1,
line_type=cv2.LINE_AA)
cv2.putText(gray, str(max_loc), max_loc,
cv2.FONT_HERSHEY_COMPLEX_SMALL, 1,
(255, 255, 255), 2, cv2.LINE_AA)
gray = cv2.drawMarker(gray,
self.goal_loc, (0, 0, 255),
markerType=cv2.MARKER_STAR,
markerSize=20,
thickness=1,
line_type=cv2.LINE_AA)
cv2.imshow("disks and their locations", gray)
self.gray = gray
#cv2.imwrite("response" + str(datetime.datetime.now()) + ".png", gray)
height, width = gray.shape[:2]
print("height: ", height, " width:", width)
bytes_per_line = width
image_for_pixmap = QtGui.QImage(gray, width, height,
QtGui.QImage.Format_Grayscale8)
self.disksDisplay.setPixmap(
QPixmap.fromImage(image_for_pixmap))
self.disksDisplay.show()
self.find_disks_enabled = False
self.recompute_target_coord()
if self.find_disks_roi_enabled:
gray = cv2.cvtColor(new_image, cv2.COLOR_BGR2GRAY)
self.disk_locations = cv2_worker.find_disks_roi(
gray, self.target_disk_loc)
print("disks:", self.disk_locations)
for max_loc in self.disk_locations:
print("max loc", max_loc)
gray = cv2.drawMarker(gray,
max_loc, (255, 255, 255),
markerType=cv2.MARKER_CROSS,
markerSize=20,
thickness=1,
line_type=cv2.LINE_AA)
cv2.putText(gray, str(max_loc), max_loc,
cv2.FONT_HERSHEY_COMPLEX_SMALL, 1,
(255, 255, 255), 2, cv2.LINE_AA)
gray = cv2.drawMarker(gray,
self.goal_loc, (0, 0, 255),
markerType=cv2.MARKER_STAR,
markerSize=20,
thickness=1,
line_type=cv2.LINE_AA)
cv2.imwrite("response" + str(datetime.datetime.now()) + ".png",
gray)
cv2.imshow("disks and their locations", gray)
height, width = gray.shape[:2]
print("height: ", height, " width:", width)
bytes_per_line = width
image_for_pixmap = QtGui.QImage(gray, width, height,
QtGui.QImage.Format_Grayscale8)
self.disksDisplay.setPixmap(
QPixmap.fromImage(image_for_pixmap))
self.disksDisplay.show()
self.find_disks_roi_enabled = False
#self.recompute_target_coord()
for max_loc in self.disk_locations:
new_image = cv2.drawMarker(new_image,
max_loc, (0, 0, 255),
markerType=cv2.MARKER_CROSS,
markerSize=20,
thickness=1,
line_type=cv2.LINE_AA)
new_image = cv2.drawMarker(new_image,
self.goal_loc, (0, 255, 255),
markerType=cv2.MARKER_DIAMOND,
markerSize=20,
thickness=1,
line_type=cv2.LINE_AA)
new_image = cv2.drawMarker(new_image,
self.target_disk_loc, (255, 255, 0),
markerType=cv2.MARKER_TILTED_CROSS,
markerSize=20,
thickness=1,
line_type=cv2.LINE_AA)
new_image = cv2.drawMarker(new_image,
self.laser_loc, (255, 0, 0),
markerType=cv2.MARKER_STAR,
markerSize=20,
thickness=1,
line_type=cv2.LINE_AA)
new_image = cv2.drawMarker(new_image,
self.desired_laser_coord, (0, 255, 0),
markerType=cv2.MARKER_STAR,
markerSize=20,
thickness=1,
line_type=cv2.LINE_AA)
cv2.imshow("raw", new_image)
image = cv2.resize(new_image, (1200, 800))
height, width, channel = image.shape
bytes_per_line = 3 * width
image_for_pixmap = QtGui.QImage(image, width, height,
bytes_per_line,
QtGui.QImage.Format_RGB888)
self.imageDisplay.setPixmap(QPixmap(image_for_pixmap))
self.imageDisplay.show()
def find_disks(self):
"Function for enabling find disk routine"
self.find_disks_enabled = True
def camera_changed(self):
try:
self.camera.release()
self.camera = cv2.VideoCapture(self.cameraComboBox.currentIndex())
self.camera.set(cv2.CAP_PROP_FRAME_WIDTH, 800)
time.sleep(0.1)
self.camera.set(cv2.CAP_PROP_FRAME_HEIGHT, 600)
time.sleep(0.1)
except:
self.camera = False
