def initUI(self):
self.listWidget = QListWidget()
self.initDevices()
self.treeWidget = QTreeWidget()
self.treeWidget.itemPressed.connect(self.onItemPressed)
self.treeWidget.setColumnCount(4)
self.treeWidget.setColumnWidth(0, 250)
self.treeWidget.setColumnWidth(1, 300)
self.treeWidget.setColumnWidth(2, 300)
self.treeWidget.setColumnWidth(3, 150)
self.treeWidget.setHeaderLabels(["Service", "Service UUID", "Characteristic UUID", "Characteristic Property"])
btn = QPushButton("Read Services")
btn.clicked.connect(self.onPushButton)
groupDevices = QGroupBox("Devices")
groupDevices.setMaximumWidth(300)
vbox = QVBoxLayout()
vbox.addWidget(self.listWidget)
vbox.addWidget(btn)
groupDevices.setLayout(vbox)
self.btnR = QPushButton("Read")
self.btnR.clicked.connect(self.onReadButton)
self.btnW = QPushButton("Write")
self.btnW.clicked.connect(self.onWriteButton)
self.lneI = QLineEdit()
self.chkN = QCheckBox("Notify")
self.chkN.toggled.connect(self.onNotifyCheck)
hbox = QHBoxLayout()
hbox.addWidget(self.btnR)
hbox.addWidget(self.btnW)
hbox.addWidget(self.lneI)
hbox.addWidget(self.chkN)
groupProperty = QGroupBox("Property")
#groupProperty.setLayout(vbox)
groupProperty.setLayout(hbox)
groupServices = QGroupBox("Services")
vbox = QVBoxLayout()
vbox.addWidget(self.treeWidget)
vbox.addWidget(groupProperty)
groupServices.setLayout(vbox)
hbox = QHBoxLayout()
hbox.addWidget(groupDevices)
hbox.addWidget(groupServices)
self.setLayout(hbox)
self.setGeometry(300, 300, 800, 600)
self.setWindowTitle('BLE Discover')
self.show()
class Card(QWidget):
def __init__(self, parent: QWidget, card_details: Dict[str, Any]):
super().__init__()
if parent is not None:
self.setParent(parent)
self.model = create_card(card_details)
self.setupUi()
def get_card_background_colour(self):
if isinstance(self.model, SpellCard):
return QColor(CardColours[CardType.SPELL])
elif isinstance(self.model, TrapCard):
return QColor(CardColours[CardType.TRAP])
else:
pass
def setupUi(self):
self.main_layout = QVBoxLayout()
self.name_attr_layout = QHBoxLayout()
self.name_label = QLabel(self.model.name)
font = self.name_label.font()
font.setBold(True)
font.setCapitalization(QFont.AllUppercase)
font.setPointSize(12)
self.name_label.setFont(font)
self.name_label.setMargin(5)
pixmap = get_attr_icon(self.model.attribute)
self.attr_icon = QLabel()
self.attr_icon.setPixmap(pixmap)
self.attr_icon.setAlignment(Qt.AlignRight)
self.name_attr_layout.addWidget(self.name_label)
self.name_attr_layout.addWidget(self.attr_icon)
self.main_layout.addLayout(self.name_attr_layout)
self.level_layout = QHBoxLayout()
self.main_layout.addLayout(self.level_layout)
self.picture_frame = QFrame()
self.picture_frame.setFixedSize(250, 250)
self.picture_frame.setFrameStyle(QFrame.Box | QFrame.Plain)
self.picture_frame.setFrameShadow(QFrame.Shadow.Raised)
self.picture_frame.setLineWidth(1)
self.picture_frame.setContentsMargins(0, 0, 0, 0)
self.picture_frame.setLayout(QGridLayout())
self.image_holder = QLabel()
pixmap = self._get_card_image()
self.image_holder.setPixmap(
pixmap.scaled(
self.picture_frame.width(),
self.picture_frame.height(),
Qt.KeepAspectRatio,
))
self.picture_frame.layout().addWidget(self.image_holder)
self.main_layout.addWidget(self.picture_frame)
# Card sets here?
self.desc_group_box = QGroupBox()
self.desc_group_box.setMaximumWidth(250)
self.set_up_group_box()
self.main_layout.addWidget(self.desc_group_box)
self.id_label = QLabel(self.model.id)
self.id_label.setAlignment(Qt.AlignLeft)
self.id_label.setMargin(5)
self.main_layout.addWidget(self.id_label)
self.setLayout(self.main_layout)
pal = QPalette()
pal.setColor(QPalette.Background, self.get_card_background_colour())
self.setAutoFillBackground(True)
self.setPalette(pal)
def _get_card_image(self):
image_name = self.model.img_url.split("/")[-1]
if os.path.exists(self.get_image_path(image_name)):
image = Image.open(self.get_image_path(image_name))
else:
image_data = requests.get(self.model.img_url).content
image = Image.open(BytesIO(image_data))
image.save(self.get_image_path(image_name))
image = image.crop((44, 106, 380, 438)) # this is about correct
data = image.tobytes("raw", "RGB")
qimage = QImage(data, image.size[0], image.size[1],
QImage.Format_RGB888)
pixmap = QPixmap.fromImage(qimage)
return pixmap
def get_image_path(self, image_name):
return os.path.join(os.getcwd(), "images", image_name)
def set_up_group_box(self):
self.desc_group_box.setLayout(QVBoxLayout())
self.desc_label = QLabel(self.model.desc)
self.desc_label.setWordWrap(True)
self.desc_group_box.layout().addWidget(self.desc_label)
if isinstance(self.model, (MonsterCard)):
self.desc_group_box.setTitle(self.get_group_box_title())
line = QFrame()
line.setFrameShape((QFrame.HLine))
line.setFrameShadow(QFrame.Sunken)
self.desc_group_box.layout().addWidget(line)
label = QLabel(
f"ATK/{self.model.attack} DEF/{self.model.defence}")
label.setAlignment(Qt.AlignRight)
self.desc_group_box.layout().addWidget(label)
def get_group_box_title(self):
return "[TEST/TEST]"
class Widget(QWidget):
def __init__(self):
QWidget.__init__(self)
# Data for plotting and marker data storage
self.data = {}
self.slice_index = {
'ind1': 0,
'ind2': 0
}
self.marker_id = 0
self.marker_ind = []
self.marker_setpoint = {
'Marker1': 0,
'Marker2': 0,
}
# Error message dialog widget
self.error_popup = QErrorMessage()
self.error_popup.setWindowTitle('Snap file error')
# Left (List of Checkboxes)
self.list_widget = QListWidget()
#Resize width and height
self.list_widget.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Preferred)
self.list_widget.setMinimumWidth(200)
self.list_widget.setMaximumWidth(400)
# self.list_widget.setMinimumHeight(300)
self.list_widget.setMaximumHeight(500)
# Signal groupbox
self.signal_groupbox = QGroupBox('Available Signals')
self.signal_groupbox.setMinimumWidth(200)
self.signal_groupbox.setMaximumWidth(350)
self.signal_groupbox.setMinimumHeight(100)
self.sig_group_layout = QVBoxLayout()
self.signal_groupbox.setLayout(self.sig_group_layout)
# Statistics groupbox
self.stats_groupbox = QGroupBox('Statistics')
self.stats_groupbox.setMinimumWidth(200)
self.stats_groupbox.setMaximumWidth(350)
self.stats_groupbox.setMinimumHeight(240)
self.stats_group_layout = QFormLayout()
# Label initiation
# Marker Time 1
self.mark_one_time_label = QLabel('Marker1_time: ')
self.mark_one_time_value = QLabel()
# Marker Time 2
self.mark_two_time_label = QLabel('Marker2_time: ')
self.mark_two_time_value = QLabel()
# On/Off labels for 0/1 signals counter
self.on_off_label = QLabel('On/Off: ')
self.on_off_value = QLabel()
# Mean value
self.mean_label = QLabel('Mean: ')
self.mean_value = QLabel()
# Standard deviation
self.std_label = QLabel('Sigma(STD): ')
self.std_value = QLabel()
# Minimal value
self.min_label = QLabel('Min: ')
self.min_value = QLabel()
# Maximual value
self.max_label = QLabel('Max: ')
self.max_value = QLabel()
# Max - Min value
self.val_diff_label = QLabel('Max-Min: ')
self.val_diff_value = QLabel()
# Time difference (X-axis)
self.time_diff_label = QLabel('Time_diff: ')
self.time_diff_value = QLabel('')
# Row addition of labels
self.stats_group_layout.addRow(self.mark_one_time_label,
self.mark_one_time_value)
self.stats_group_layout.addRow(self.mark_two_time_label,
self.mark_two_time_value)
self.stats_group_layout.addRow(self.time_diff_label,
self.time_diff_value)
self.stats_group_layout.addRow(self.on_off_label, self.on_off_value)
self.stats_group_layout.addRow(self.mean_label, self.mean_value)
self.stats_group_layout.addRow(self.std_label, self.std_value)
self.stats_group_layout.addRow(self.min_label, self.min_value)
self.stats_group_layout.addRow(self.max_label, self.max_value)
self.stats_group_layout.addRow(self.val_diff_label,
self.val_diff_value)
self.stats_groupbox.setLayout(self.stats_group_layout)
# Set markers section of the application (bottom left)
self.marker_grid = QGridLayout()
self.marker_one_notice = QLabel()
self.marker_two_notice = QLabel()
self.set_marker_one_label = QLabel('Set Marker1:')
self.set_marker_two_label = QLabel('Set Marker2:')
self.set_marker_one_value = QLineEdit()
self.set_marker_one_value.setMaximumWidth(100)
self.set_marker_two_value = QLineEdit()
self.set_marker_two_value.setMaximumWidth(100)
self.marker_grid.addWidget(self.set_marker_one_label)
self.marker_grid.addWidget(self.set_marker_one_value)
self.marker_grid.addWidget(self.marker_one_notice)
self.marker_grid.addWidget(self.set_marker_two_label)
self.marker_grid.addWidget(self.set_marker_two_value)
self.marker_grid.addWidget(self.marker_two_notice)
# Leftside app layout
self.v_layout = QVBoxLayout()
self.v_layout.addWidget(self.list_widget)
self.v_layout.addWidget(self.signal_groupbox)
self.v_layout.addWidget(self.stats_groupbox)
self.v_layout.addLayout(self.marker_grid)
# Matplotlib figure
self.fig = Figure(figsize=(5, 3))
self.canvas = FigureCanvas(self.fig)
self.canvas.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.ax = self.canvas.figure.subplots()
self.ax.grid()
self.ax.set_xlabel('Time[s]')
self.fig.suptitle('Parameter Plot')
# QWidget Layout
self.h_layout = QHBoxLayout()
self.h_layout.addLayout(self.v_layout)
self.h_layout.addWidget(self.canvas)
# Set the layout to the QWidget
self.setLayout(self.h_layout)
# ListWidget and plot connections
self.list_widget.itemChanged.connect(self.item_changed)
self.click_event = self.fig.canvas.mpl_connect('button_press_event',
self.on_click)
self.set_marker_one_value.returnPressed.connect(
lambda: self.add_marker('one'))
self.set_marker_two_value.returnPressed.connect(
lambda: self.add_marker('two'))
# Add radio button when signal is checked for plotting
def add_radio_button(self, name):
self.rad_btn = QRadioButton(name)
self.rad_btn.toggled.connect(self.calculate_signal_stats)
self.sig_group_layout.addWidget(self.rad_btn)
# Remove radio button when signal is unchecked for plotting
def remove_radio_button(self, name):
for item in self.signal_groupbox.children():
try:
if item.text() == name:
item.setParent(None)
except AttributeError:
pass
# Remove all radiobuttons on new data load
def clear_signals(self):
count = 0
for item in self.signal_groupbox.children():
if count == 0:
count = 1
continue
else:
item.setParent(None)
# Check state of all radiobuttons, if none is checked remove stats values
def check_signals(self):
count = 0
num_of_check = 0
for item in self.signal_groupbox.children():
if count == 0:
count = 1
continue
else:
if item.isChecked():
num_of_check += 1
# If no radiobuttons are checked, remove stats
if num_of_check == 0:
self.mean_value.setText('')
self.std_value.setText('')
self.max_value.setText('')
self.min_value.setText('')
self.val_diff_value.setText('')
self.on_off_value.setText('')
# Item additon of listWidget
def fill_list(self, list_items):
self.list_widget.clear()
for column in list_items:
item = QListWidgetItem(column)
item.setFlags(item.flags() | QtCore.Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Unchecked)
self.list_widget.addItem(item)
self.show()
# If new data is loaded, replace the old one
def replace_data(self, temp):
if not temp == self.data:
self.data = temp
self.clear_signals()
@Slot()
# Item state changed in listWidget event handler
def item_changed(self, item):
if item.checkState() == Qt.Unchecked:
self.remove_plot(item.text())
self.remove_radio_button(item.text())
self.check_signals()
else:
self.add_plot(self.data['Time'],
self.data[item.text()], item.text())
self.add_radio_button(item.text())
# Method for plotting data
def add_plot(self, x_data, y_data, name):
self.ax.plot(x_data, y_data, label=name, picker=3)
self.ax.grid(True)
self.ax.relim()
self.ax.set_xlabel('Time[s]')
self.ax.autoscale_view()
self.ax.legend(loc='upper right')
self.canvas.draw()
# Method for marker addition via QLineEdit
def add_marker(self, label):
# Check if any signal is plotted
sig_count = 0
for i in range(self.list_widget.count()):
if self.list_widget.item(i).checkState() == Qt.Checked:
sig_count += 1
if sig_count == 0:
self.marker_one_notice.setText('No active signal!')
self.marker_two_notice.setText('No active signal!')
return
try:
max_time = self.data['Time'][-1]
min_time = self.data['Time'][0]
except KeyError:
self.marker_one_notice.setText('Signal data not loaded!')
self.marker_two_notice.setText('Signal data not loaded!')
if label == 'one':
try:
mark1_value = float(self.set_marker_one_value.text())
if mark1_value < max_time and mark1_value > min_time:
if self.marker_id == 0:
self.marker_id += 1
label_id = self.marker_id
elif self.marker_id == 1:
self.marker_id += 1
label_id = self.marker_id
self.remove_marker('first')
else:
self.remove_marker('first')
label_id = 1
self.marker_one_notice.setText('')
self.marker_setpoint['Marker1'] = mark1_value
self.mark_one_time_value.setText(
self.set_marker_one_value.text())
self.calculate_marker_stats()
self.calculate_signal_stats()
# Draw the marker
L = self.ax.axvline(
x=float(self.set_marker_one_value.text()),
linestyle='dashed',
color='red',
label='_Marker' + str(label_id))
self.fig.canvas.draw()
else:
self.marker_one_notice.setText('Marker1 out of bounds')
except ValueError:
self.marker_one_notice.setText('Non-Valid value entered!')
else:
try:
mark2_value = float(self.set_marker_two_value.text())
if mark2_value < max_time and mark2_value > min_time:
if self.marker_id == 1:
self.marker_id += 1
label_id = self.marker_id
elif self.marker_id == 2:
label_id = 2
self.remove_marker('second')
else:
self.marker_two_notice.setText('Marker1 not placed')
self.marker_two_notice.setText('')
self.marker_setpoint['Marker2'] = mark2_value
self.mark_two_time_value.setText(
self.set_marker_two_value.text())
self.calculate_marker_stats()
self.calculate_signal_stats()
# Draw the marker
L = self.ax.axvline(
x=float(self.set_marker_two_value.text()),
linestyle='dashed',
color='red',
label='_Marker' + str(label_id))
self.fig.canvas.draw()
else:
self.marker_two_notice.setText('Marker2 out of bounds')
except:
self.marker_two_notice.setText('Non-Valid value entered!')
# Marker removal method
def remove_marker(self, label):
for item in self.ax.lines:
if 'Marker' in item.get_label():
self.marker_ind.append(item)
# If there are two markers remove them from plot and adjust marker
# time labels
if label == 'both':
self.marker_ind[0].remove()
self.marker_ind[1].remove()
self.marker_ind = []
self.marker_setpoint['Marker1'] = 0
self.marker_setpoint['Marker2'] = 0
self.mark_one_time_value.setText('')
self.mark_two_time_value.setText('')
self.time_diff_value.setText('')
self.marker_id = 0
# Remove only marker1
elif label == 'first':
self.marker_ind[0].remove()
self.marker_ind = []
self.marker_setpoint['Marker1'] = 0
self.mark_one_time_value.setText('')
self.marker_id -= 1
elif label == 'second':
self.marker_ind[1].remove()
self.marker_ind = []
self.marker_setpoint['Marker2'] = 0
self.mark_two_time_value.setText('')
self.marker_id -= 1
self.ax.set_xlabel('Time[s]')
self.canvas.draw()
# Method for plot removal
def remove_plot(self, name):
cnt = 0
for item in self.ax.lines:
if item.get_label() == name:
self.ax.lines[cnt].remove()
cnt += 1
self.ax.relim()
self.ax.autoscale_view()
self.ax.legend(loc='upper right')
self.ax.set_xlabel('Time[s]')
self.canvas.draw()
# Check if all elements are unticked
counter = 0
for i in range(self.list_widget.count()):
if self.list_widget.item(i).checkState() == Qt.Checked:
counter +=1
if counter == 0:
self.remove_marker('both')
# On click event for plot, only two markers can be active at the time
def on_click(self, event):
try:
# Catch left click event
if event.button == 1:
x = event.xdata
if self.marker_id < 2:
if self.marker_id == 0:
self.marker_setpoint['Marker1'] = round(x)
self.mark_one_time_value.setText(
str(self.marker_setpoint['Marker1']))
self.calculate_marker_stats()
self.calculate_signal_stats()
else:
self.marker_setpoint['Marker2'] = round(x)
self.mark_two_time_value.setText(
str(self.marker_setpoint['Marker2']))
self.calculate_marker_stats()
self.calculate_signal_stats()
self.marker_id += 1
L = self.ax.axvline(x=x,
linestyle='dashed',
color='red',
label='_Marker' + str(self.marker_id))
self.fig.canvas.draw()
# Catch right click event
elif event.button == 3:
self.remove_marker('both')
except TypeError:
pass
# Marker analysis method
def calculate_marker_stats(self):
if self.marker_setpoint['Marker2'] == 0:
diff = self.data['Time'][-1] - self.marker_setpoint['Marker1']
self.time_diff_value.setText(str(diff))
else:
diff = self.marker_setpoint['Marker2'] - \
self.marker_setpoint['Marker1']
self.time_diff_value.setText(convert_seconds(diff))
# Signal analysis method
def calculate_signal_stats(self):
self.check_signals()
selected_signal = ''
signal_data = []
num_off, num_on = 0, 0
for item in self.signal_groupbox.children():
try:
if item.isChecked():
# Signal extraction block
selected_signal = item.text()
# If only one marker, Marker1 is placed on graph
if self.marker_setpoint['Marker2'] == 0 and self.marker_setpoint['Marker1'] != 0:
for i in range(len(self.data['Time'])):
if self.data['Time'][i] > self.marker_setpoint['Marker1']:
self.slice_index['ind1'] = i
break
signal_data = np.asarray(
self.data[selected_signal][self.slice_index['ind1']:],
dtype=np.float32)
# Both markers, Marker1 and Marker2 are present on graph
elif self.marker_setpoint['Marker1'] != 0 and self.marker_setpoint['Marker2'] != 0:
for i in range(len(self.data['Time'])):
if self.data['Time'][i] > self.marker_setpoint['Marker1']:
self.slice_index['ind1'] = i
break
for i in range(len(self.data['Time'])):
if self.data['Time'][len(self.data['Time']) - i - 1] < self.marker_setpoint['Marker2']:
self.slice_index['ind2'] = len(self.data['Time']) - i
break
signal_data = np.asarray(
self.data[selected_signal][self.slice_index['ind1']:self.slice_index['ind2'] - 1],
dtype=np.float32)
# No markers present, whole signal stats are showed
else:
signal_data = np.asarray(self.data[selected_signal],
dtype=np.float32)
try:
# Signal mean calculation
self.mean_value.setText(str(np.mean(signal_data)))
# Standard deviation
self.std_value.setText(str(np.std(signal_data)))
# Maximum value
self.max_value.setText(str(np.max(signal_data)))
# Minimum value
self.min_value.setText(str(np.min(signal_data)))
# Max - Min
self.val_diff_value.setText(str(np.max(signal_data) -
(np.min(signal_data))))
if np.max(signal_data) == 1.0:
for i in range(len(signal_data)):
if i != len(signal_data) - 1:
temp = signal_data[i] - signal_data[i+1]
if temp == 1:
num_off += 1
elif temp == -1:
num_on += 1
self.on_off_value.setText(str(num_on) +
'\\' + str(num_off))
except ValueError:
err_line1 = 'Missing data, result is empty array!'
err_line2 = '\n Please check snap file.'
self.error_popup.showMessage(err_line1 + err_line2)
except AttributeError:
pass
class NumberConversion(QWidget):
def __init__(self):
super(NumberConversion, self).__init__()
# App attributes
self.bin_format_base = None
self.bin_format_base_byte = None
# Use language settings
self.ml = ManageLng()
main_layout = QGridLayout()
self.setLayout(main_layout)
# Input
self.inputbox = QGroupBox(
self.ml.get_tr_text("tab_num_conv_inputbox_gbox_name"))
self.inputbox.setMaximumWidth(400)
main_layout.addWidget(self.inputbox, 0, 0)
inputbox_layout = QGridLayout()
inputbox_layout.setHorizontalSpacing(25)
inputbox_layout.setVerticalSpacing(35)
inputbox_layout.setAlignment(Qt.AlignCenter)
self.inputbox.setLayout(inputbox_layout)
self.input_number_label = QLabel(
self.ml.get_tr_text("tab_num_conv_inputbox_in_number_lab"))
self.input_number_textfield = QLineEdit()
self.input_number_textfield.setPlaceholderText("192")
self.input_number_textfield.setAlignment(Qt.AlignCenter)
self.input_number_textfield.returnPressed.connect(self.convert_action)
inputbox_layout.addWidget(self.input_number_label,
0,
0,
alignment=Qt.AlignCenter)
inputbox_layout.addWidget(self.input_number_textfield, 0, 1)
button_layout = QVBoxLayout()
self.bin_button = QRadioButton(
self.ml.get_tr_text("tab_num_conv_inputbox_bin_chkbox"))
self.bin_button.clicked.connect(
lambda: self.input_number_textfield.setPlaceholderText("11100010"))
self.dec_button = QRadioButton(
self.ml.get_tr_text("tab_num_conv_inputbox_dec_chkbox"))
self.dec_button.clicked.connect(
lambda: self.input_number_textfield.setPlaceholderText("192"))
self.hex_button = QRadioButton(
self.ml.get_tr_text("tab_num_conv_inputbox_hex_chkbox"))
self.hex_button.clicked.connect(
lambda: self.input_number_textfield.setPlaceholderText("FF"))
self.dec_button.setChecked(True)
button_layout.addWidget(self.bin_button)
button_layout.addWidget(self.dec_button)
button_layout.addWidget(self.hex_button)
inputbox_layout.addLayout(button_layout, 0, 3, 1, 2)
self.convert_button = QPushButton(
self.ml.get_tr_text("tab_num_conv_inputbox_conv_btn"))
self.convert_button.clicked.connect(self.convert_action)
self.convert_button.setIcon(QIcon("static/images/exchange.png"))
inputbox_layout.addWidget(self.convert_button,
1,
1,
alignment=Qt.AlignCenter)
# Output
self.outputbox = QGroupBox(
self.ml.get_tr_text("tab_num_conv_outputbox_gbox_name"))
main_layout.addWidget(self.outputbox, 0, 1)
outputbox_layout = QGridLayout()
outputbox_layout.setHorizontalSpacing(25)
self.outputbox.setLayout(outputbox_layout)
self.bin_label = QLabel(
self.ml.get_tr_text("tab_num_conv_outputbox_bin_lab"))
self.bin_label.setAlignment(Qt.AlignCenter)
self.dec_label = QLabel(
self.ml.get_tr_text("tab_num_conv_outputbox_dec_lab"))
self.dec_label.setAlignment(Qt.AlignCenter)
self.hex_label = QLabel(
self.ml.get_tr_text("tab_num_conv_outputbox_hex_lab"))
self.hex_label.setAlignment(Qt.AlignCenter)
self.bin_output = QLineEdit()
self.bin_output.setReadOnly(True)
self.bin_output.setAlignment(Qt.AlignCenter)
self.dec_output = QLineEdit()
self.dec_output.setReadOnly(True)
self.dec_output.setAlignment(Qt.AlignCenter)
self.hex_output = QLineEdit()
self.hex_output.setReadOnly(True)
self.hex_output.setAlignment(Qt.AlignCenter)
self.bin_output_copy_button = QPushButton(
self.ml.get_tr_text("tab_num_conv_outputbox_copy_btn"))
self.bin_output_copy_button.setIcon(
QIcon("static/images/copy_clipboard.png"))
self.bin_output_copy_button.clicked.connect(
lambda: copy_action(self.bin_output.text()))
self.dec_output_copy_button = QPushButton(
self.ml.get_tr_text("tab_num_conv_outputbox_copy_btn"))
self.dec_output_copy_button.setIcon(
QIcon("static/images/copy_clipboard.png"))
self.dec_output_copy_button.clicked.connect(
lambda: copy_action(self.dec_output.text()))
self.hex_output_copy_button = QPushButton(
self.ml.get_tr_text("tab_num_conv_outputbox_copy_btn"))
self.hex_output_copy_button.setIcon(
QIcon("static/images/copy_clipboard.png"))
self.hex_output_copy_button.clicked.connect(
lambda: copy_action(self.hex_output.text()))
outputbox_layout.addWidget(self.bin_label, 0, 0)
outputbox_layout.addWidget(self.bin_output, 0, 1)
outputbox_layout.addWidget(self.bin_output_copy_button, 0, 2)
outputbox_layout.addWidget(self.dec_label, 1, 0)
outputbox_layout.addWidget(self.dec_output, 1, 1)
outputbox_layout.addWidget(self.dec_output_copy_button, 1, 2)
outputbox_layout.addWidget(self.hex_label, 2, 0)
outputbox_layout.addWidget(self.hex_output, 2, 1)
outputbox_layout.addWidget(self.hex_output_copy_button, 2, 2)
# IP address/mask number conversion
self.ip_address_number_conversion_box = QGroupBox(
self.ml.get_tr_text("tab_num_conv_ip_mask_conv_gbox_name"))
main_layout.addWidget(self.ip_address_number_conversion_box, 1, 0, 1,
2)
ip_address_number_conversion_layout = QGridLayout()
ip_address_number_conversion_layout.setAlignment(Qt.AlignCenter)
ip_address_number_conversion_layout.setHorizontalSpacing(25)
ip_address_number_conversion_layout.setVerticalSpacing(24)
self.ip_address_number_conversion_box.setLayout(
ip_address_number_conversion_layout)
self.input_label = QLabel(
self.ml.get_tr_text("tab_num_conv_ip_mask_conv_in_lab"))
self.input_label.setAlignment(Qt.AlignCenter)
self.input_label.setMaximumWidth(150)
self.input_textfield = QLineEdit()
self.input_textfield.setPlaceholderText("192.168.1.1")
self.input_textfield.setAlignment(Qt.AlignLeft)
self.input_textfield.setMaximumWidth(300)
self.input_textfield.setAlignment(Qt.AlignCenter)
self.input_textfield.returnPressed.connect(self.convert_action_2)
ip_address_number_conversion_layout.addWidget(self.input_label, 0, 0)
ip_address_number_conversion_layout.addWidget(self.input_textfield, 0,
1)
button_layout_2 = QVBoxLayout()
self.dec_to_bin_button = QRadioButton(
self.ml.get_tr_text("tab_num_conv_ip_mask_conv_dectobin"))
self.dec_to_bin_button.clicked.connect(
lambda: self.input_textfield.setPlaceholderText("192.168.1.1"))
self.dec_to_bin_button.setMaximumWidth(150)
self.bin_to_dec_button = QRadioButton(
self.ml.get_tr_text("tab_num_conv_ip_mask_conv_bintodec"))
self.bin_to_dec_button.clicked.connect(
lambda: self.input_textfield.setPlaceholderText(
"11000000.10101000.00000001.00000001"))
self.bin_to_dec_button.setMaximumWidth(150)
self.dec_to_bin_button.setChecked(True)
button_layout_2.addWidget(self.dec_to_bin_button)
button_layout_2.addWidget(self.bin_to_dec_button)
ip_address_number_conversion_layout.addLayout(button_layout_2, 0, 2)
self.output_label = QLabel(
self.ml.get_tr_text("tab_num_conv_ip_mask_conv_out_lab"))
self.output_label.setAlignment(Qt.AlignCenter)
self.output_textfield = QLineEdit()
self.output_textfield.setMaximumWidth(300)
self.output_textfield.setReadOnly(True)
self.output_textfield.setAlignment(Qt.AlignCenter)
ip_address_number_conversion_layout.addWidget(self.output_label, 1, 0)
ip_address_number_conversion_layout.addWidget(self.output_textfield, 1,
1)
self.output_textfield_copy_button = QPushButton(
self.ml.get_tr_text("tab_num_conv_ip_mask_conv_copy_btn"))
self.output_textfield_copy_button.setIcon(
QIcon("static/images/copy_clipboard.png"))
self.output_textfield_copy_button.clicked.connect(
lambda: copy_action(self.output_textfield.text()))
ip_address_number_conversion_layout.addWidget(
self.output_textfield_copy_button, 1, 2, alignment=Qt.AlignLeft)
self.convert_button_2 = QPushButton(
self.ml.get_tr_text("tab_num_conv_ip_mask_conv_convert_btn"))
self.convert_button_2.clicked.connect(self.convert_action_2)
self.convert_button_2.setIcon(QIcon("static/images/exchange.png"))
ip_address_number_conversion_layout.addWidget(
self.convert_button_2, 2, 0, 1, 3, alignment=Qt.AlignHCenter)
def convert_action(self):
if is_empty(self.input_number_textfield.text()):
PopupWindow("warning",
self.ml.get_tr_text("tab_num_conv_warning01"),
self.input_number_textfield)
else:
if self.bin_button.isChecked():
self.source_bin(self.input_number_textfield.text())
elif self.dec_button.isChecked():
self.source_dec(self.input_number_textfield.text())
else:
self.source_hex(self.input_number_textfield.text())
def source_bin(self, bin_number):
bin_number_corrected = get_corrected_number(bin_number)
bin_number_corrected_byte = bin_number_corrected.rjust(8, "0")
if not is_correct_binary(bin_number_corrected):
PopupWindow("warning",
self.ml.get_tr_text("tab_num_conv_warning02"),
self.input_number_textfield)
else:
if 0 <= int(bin_number_corrected, 2) <= 255:
if bin_number_corrected != bin_number_corrected_byte:
self.bin_format_base = bin_number_corrected
self.bin_format_base_byte = bin_number_corrected_byte
bin_format = get_bin_format(
self.bin_format_base,
self.ml.get_tr_text("byte_format_str"),
self.bin_format_base_byte)
else:
bin_format = self.bin_format_base
else:
bin_format = bin_number_corrected
dec_format = str(int(bin_number_corrected, 2))
hex_format = hex(int(bin_number_corrected, 2)).replace("0x",
"").upper()
self.bin_output.setText(bin_format)
self.dec_output.setText(dec_format)
self.hex_output.setText(hex_format)
def source_dec(self, dec_number):
dec_number_corrected = get_corrected_number(dec_number)
if not is_correct_decimal(dec_number_corrected):
PopupWindow("warning",
self.ml.get_tr_text("tab_num_conv_warning03"),
self.input_number_textfield)
else:
if 0 <= int(dec_number_corrected) <= 255:
self.bin_format_base = bin(int(dec_number_corrected)).replace(
"0b", "")
self.bin_format_base_byte = self.bin_format_base.rjust(8, "0")
if self.bin_format_base != self.bin_format_base_byte:
bin_format = get_bin_format(
self.bin_format_base,
self.ml.get_tr_text("byte_format_str"),
self.bin_format_base_byte)
else:
bin_format = self.bin_format_base
else:
bin_format = bin(int(dec_number_corrected)).replace("0b", "")
dec_format = dec_number_corrected
hex_format = hex(int(dec_number_corrected)).replace("0x",
"").upper()
self.bin_output.setText(bin_format)
self.dec_output.setText(dec_format)
self.hex_output.setText(hex_format)
def source_hex(self, hex_number):
hex_number_corrected = get_corrected_number(hex_number).upper()
if not is_correct_hexadecimal(hex_number_corrected):
PopupWindow("warning",
self.ml.get_tr_text("tab_num_conv_warning04"),
self.input_number_textfield)
else:
if 0 <= int(hex_number_corrected, 16) <= 255:
self.bin_format_base = bin(int(hex_number_corrected,
16)).replace("0b", "")
self.bin_format_base_byte = self.bin_format_base.rjust(8, "0")
if self.bin_format_base != self.bin_format_base_byte:
bin_format = get_bin_format(
self.bin_format_base,
self.ml.get_tr_text("byte_format_str"),
self.bin_format_base_byte)
else:
bin_format = self.bin_format_base
else:
bin_format = bin(int(hex_number_corrected,
16)).replace("0b", "")
dec_format = str(int(hex_number_corrected, 16))
hex_format = hex_number_corrected
self.bin_output.setText(bin_format)
self.dec_output.setText(dec_format)
self.hex_output.setText(hex_format)
def convert_action_2(self):
if is_empty(self.input_textfield.text()):
PopupWindow("warning",
self.ml.get_tr_text("tab_num_conv_warning05"),
self.input_textfield)
elif self.dec_to_bin_button.isChecked():
if is_correct_any_ip_dec(self.input_textfield.text()):
self.output_textfield.setText(
dec_to_bin(self.input_textfield.text()))
else:
PopupWindow("warning",
self.ml.get_tr_text("tab_num_conv_warning06"),
self.input_textfield)
else:
if is_correct_any_ip_bin(self.input_textfield.text()):
self.output_textfield.setText(
bin_to_dec(self.input_textfield.text()))
else:
PopupWindow("warning",
self.ml.get_tr_text("tab_num_conv_warning07"),
self.input_textfield)
def re_translate_ui(self, lang):
self.ml = ManageLng(lang)
self.inputbox.setTitle(
self.ml.get_tr_text("tab_num_conv_inputbox_gbox_name"))
self.input_number_label.setText(
self.ml.get_tr_text("tab_num_conv_inputbox_in_number_lab"))
self.bin_button.setText(
self.ml.get_tr_text("tab_num_conv_inputbox_bin_chkbox"))
self.dec_button.setText(
self.ml.get_tr_text("tab_num_conv_inputbox_dec_chkbox"))
self.hex_button.setText(
self.ml.get_tr_text("tab_num_conv_inputbox_hex_chkbox"))
self.convert_button.setText(
self.ml.get_tr_text("tab_num_conv_inputbox_conv_btn"))
self.outputbox.setTitle(
self.ml.get_tr_text("tab_num_conv_outputbox_gbox_name"))
self.bin_label.setText(
self.ml.get_tr_text("tab_num_conv_outputbox_bin_lab"))
self.dec_label.setText(
self.ml.get_tr_text("tab_num_conv_outputbox_dec_lab"))
self.hex_label.setText(
self.ml.get_tr_text("tab_num_conv_outputbox_hex_lab"))
self.bin_output_copy_button.setText(
self.ml.get_tr_text("tab_num_conv_outputbox_copy_btn"))
self.dec_output_copy_button.setText(
self.ml.get_tr_text("tab_num_conv_outputbox_copy_btn"))
self.hex_output_copy_button.setText(
self.ml.get_tr_text("tab_num_conv_outputbox_copy_btn"))
self.ip_address_number_conversion_box.setTitle(
self.ml.get_tr_text("tab_num_conv_ip_mask_conv_gbox_name"))
self.input_label.setText(
self.ml.get_tr_text("tab_num_conv_ip_mask_conv_in_lab"))
self.dec_to_bin_button.setText(
self.ml.get_tr_text("tab_num_conv_ip_mask_conv_dectobin"))
self.bin_to_dec_button.setText(
self.ml.get_tr_text("tab_num_conv_ip_mask_conv_bintodec"))
self.output_label.setText(
self.ml.get_tr_text("tab_num_conv_ip_mask_conv_out_lab"))
self.output_textfield_copy_button.setText(
self.ml.get_tr_text("tab_num_conv_ip_mask_conv_copy_btn"))
self.convert_button_2.setText(
self.ml.get_tr_text("tab_num_conv_ip_mask_conv_convert_btn"))
if self.bin_output.text():
self.bin_output.setText(
get_bin_format(self.bin_format_base,
self.ml.get_tr_text("byte_format_str"),
self.bin_format_base_byte))
def __init__(self):
QMainWindow.__init__(self)
self.setWindowTitle("Spot Extractor")
menuBar = self.buildMenuBar()
widget = QWidget(self)
layout = QGridLayout(widget)
# Main Image Window
self.scrollArea = QScrollArea()
self.imageLabel = ImageLabel(self)
self.scrollArea.setWidget(self.imageLabel)
# Text Label for Lot Name
self.lotNameTextField = QLineEdit()
self.lotNameTextField.setFixedWidth(300)
# Spot List
self.spotList = SpotListWidget(self)
# Image Box Layout
imageGroupBox = QGroupBox("Image")
imageLayout = QHBoxLayout()
imageLayout.addWidget(self.scrollArea)
imageGroupBox.setLayout(imageLayout)
# Spot List Box Layout
rightGroupBox = QGroupBox()
rightGroupBox.setMaximumWidth(300)
rightGroupLayout = QVBoxLayout()
lotNameGroupBox = QGroupBox("Lot Name")
lotNameLayout = QHBoxLayout()
lotNameLayout.addWidget(self.lotNameTextField)
lotNameGroupBox.setLayout(lotNameLayout)
spotsGroupBox = QGroupBox("Spot List")
spotsLayout = QHBoxLayout()
spotsLayout.addWidget(self.spotList)
spotsGroupBox.setLayout(spotsLayout)
rightGroupLayout.addWidget(lotNameGroupBox)
rightGroupLayout.addWidget(spotsGroupBox)
rightGroupBox.setLayout(rightGroupLayout)
# Control Buttons Box Layout
horizontalGroupBox = QGroupBox("Control Buttons")
controlButtonLayout = QHBoxLayout()
checkAllButton = QPushButton("Check All")
uncheckAllButton = QPushButton("Uncheck All")
deleteCheckedButton = QPushButton("Delete Checked")
checkAllButton.clicked.connect(self.checkAll)
uncheckAllButton.clicked.connect(self.uncheckAll)
deleteCheckedButton.clicked.connect(self.deleteAllChecked)
controlButtonLayout.addWidget(checkAllButton)
controlButtonLayout.addWidget(uncheckAllButton)
controlButtonLayout.addWidget(deleteCheckedButton)
horizontalGroupBox.setLayout(controlButtonLayout)
layout.addWidget(imageGroupBox, 0, 0)
layout.addWidget(rightGroupBox, 0, 1)
layout.addWidget(horizontalGroupBox, 1, 0, 1, 2)
self.setMenuBar(menuBar)
self.setLayout(layout)
self.setCentralWidget(widget)
class ForceActuatorBumpTestPageWidget(QWidget):
"""
Enable user to select actuator for bump test. Show graphs depicting actual
demand and measured forces. Shows button to run a bump test and stop any
running bump test.
Parameters
----------
m1m3 : `SALComm object`
SALComm communication object.
"""
def __init__(self, m1m3):
super().__init__()
self.m1m3 = m1m3
self.xIndex = self.yIndex = self.zIndex = self.sIndex = self.testedId = None
self._testRunning = False
actuatorBox = QGroupBox("Actuator")
self.actuatorsTable = QTableWidget(
max([row[FATABLE_ID] for row in FATABLE]) % 100, 12
)
self.actuatorsTable.setShowGrid(False)
def setNone(r, c):
item = QTableWidgetItem("")
item.setFlags(Qt.NoItemFlags)
self.actuatorsTable.setItem(r, c, item)
for i in range(4):
mr = min(
[
row[FATABLE_ID]
for row in FATABLE
if row[FATABLE_ID] > (100 + 100 * i)
]
)
for r in range(mr):
for c in range(i * 3, (i * 3) + 2):
setNone(r, c)
for tr in range(len(FATABLE)):
actuatorId = FATABLE[tr][FATABLE_ID]
row = (actuatorId % 100) - 1
colOffset = 3 * (int(actuatorId / 100) - 1)
def getItem(text):
item = QTableWidgetItem(text)
item.setData(Qt.UserRole, actuatorId)
return item
self.actuatorsTable.setItem(row, 0 + colOffset, getItem(str(actuatorId)))
self.actuatorsTable.setItem(row, 1 + colOffset, getItem("P"))
if FATABLE[tr][FATABLE_SINDEX] is None:
setNone(row, 2 + colOffset)
else:
self.actuatorsTable.setItem(
row,
2 + colOffset,
getItem("Y" if (FATABLE[tr][FATABLE_XINDEX] is None) else "X"),
)
self.actuatorsTable.horizontalHeader().hide()
self.actuatorsTable.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents
)
self.actuatorsTable.horizontalHeader().setStretchLastSection(False)
self.actuatorsTable.verticalHeader().hide()
self.actuatorsTable.verticalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents
)
self.actuatorsTable.itemSelectionChanged.connect(self.itemSelectionChanged)
self.actuatorsTable.setSizePolicy(
QSizePolicy.Minimum, QSizePolicy.MinimumExpanding
)
self.actuatorsTable.setFixedWidth(
sum([self.actuatorsTable.columnWidth(c) for c in range(12)])
+ self.actuatorsTable.verticalScrollBar().geometry().height() / 2
+ 1
)
actuatorLayout = QVBoxLayout()
actuatorLayout.addWidget(self.actuatorsTable)
actuatorBox.setLayout(actuatorLayout)
def testPB():
pb = QProgressBar()
pb.setMaximum(6)
return pb
self.primaryPB = testPB()
self.primaryLabelPB = QLabel("Primary")
self.secondaryPB = testPB()
self.secondaryLabelPB = QLabel("Seconday")
self.progressGroup = QGroupBox("Test progress")
progressLayout = QGridLayout()
progressLayout.addWidget(self.primaryLabelPB, 0, 0)
progressLayout.addWidget(self.primaryPB, 0, 1)
progressLayout.addWidget(self.secondaryLabelPB, 1, 0)
progressLayout.addWidget(self.secondaryPB, 1, 1)
# progressLayout.addStretch(1)
self.progressGroup.setLayout(progressLayout)
self.progressGroup.setMaximumWidth(410)
self.chart = None
self.chart_view = TimeChartView()
self.chart_view.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
def makeButton(text, clicked):
button = QPushButton(text)
button.setEnabled(False)
button.clicked.connect(clicked)
return button
self.bumpTestAllButton = makeButton("Bump test all", self.bumpTestAll)
self.bumpTestButton = makeButton("Run bump test", self.issueCommandBumpTest)
self.killBumpTestButton = makeButton(
"Stop bump test", self.issueCommandKillBumpTest
)
self.buttonLayout = QHBoxLayout()
self.buttonLayout.addWidget(self.bumpTestAllButton)
self.buttonLayout.addWidget(self.bumpTestButton)
self.buttonLayout.addWidget(self.killBumpTestButton)
self.layout = QVBoxLayout()
self.forms = QHBoxLayout()
self.forms.addWidget(actuatorBox)
self.forms.addWidget(self.progressGroup)
self.forms.addWidget(SALLog.Widget(self.m1m3))
self.layout.addLayout(self.forms)
self.layout.addWidget(self.chart_view)
self.layout.addLayout(self.buttonLayout)
self.setLayout(self.layout)
self.m1m3.detailedState.connect(self.detailedState)
self.m1m3.forceActuatorBumpTestStatus.connect(self.forceActuatorBumpTestStatus)
@Slot()
def itemSelectionChanged(self):
"""Called when an actuator is selected from the list."""
items = self.actuatorsTable.selectedItems()
if len(items) == 0:
return
if len(items) > 1:
actuators = f"{items[0].data(Qt.UserRole)}..{items[-1].data(Qt.UserRole)}"
else:
actuators = f"{items[0].data(Qt.UserRole)}"
self.bumpTestButton.setEnabled(not (self._anyCylinderRunning()))
self.bumpTestButton.setText(f"Run bump test for FA ID {actuators}")
def toggledTest(self, toggled):
"""Called when primary or secondary tests check box are toggled."""
self.bumpTestButton.setEnabled(
self.actuatorsTable.currentItem() is not None
and not (self._anyCylinderRunning())
)
@asyncSlot()
async def bumpTestAll(self):
for i in range(4):
colOffset = i * 3
self.actuatorsTable.setRangeSelected(
QTableWidgetSelectionRange(
0,
1 + colOffset,
self.actuatorsTable.rowCount() - 1,
2 + colOffset,
),
False,
)
self.actuatorsTable.setRangeSelected(
QTableWidgetSelectionRange(
0, colOffset, self.actuatorsTable.rowCount() - 1, colOffset
),
True,
)
await self._testItem(self.actuatorsTable.selectedItems()[0])
self.bumpTestButton.setEnabled(False)
@asyncSlot()
async def issueCommandBumpTest(self):
"""Call M1M3 bump test command."""
await self._testItem(self.actuatorsTable.selectedItems()[0])
async def _testItem(self, item):
self.actuatorsTable.scrollToItem(item)
self.testedId = item.data(Qt.UserRole)
item.setSelected(False)
self.zIndex = actuatorIDToIndex(self.testedId)
self.xIndex = FATABLE[self.zIndex][FATABLE_XINDEX]
self.yIndex = FATABLE[self.zIndex][FATABLE_YINDEX]
self.sIndex = FATABLE[self.zIndex][FATABLE_SINDEX]
items = []
if self.xIndex is not None:
items.append("X")
if self.yIndex is not None:
items.append("Y")
items.append("Z")
items = (
list(map(lambda s: "Applied " + s, items))
+ [None]
+ list(map(lambda s: "Measured " + s, items))
)
if self.chart is not None:
self.chart.clearData()
self.chart = TimeChart({"Force (N)": items})
self.chart_view.setChart(self.chart)
self.progressGroup.setTitle(f"Test progress {self.testedId}")
if self.sIndex is not None:
self.secondaryLabelPB.setText("Y" if self.xIndex is None else "X")
await self.m1m3.remote.cmd_forceActuatorBumpTest.set_start(
actuatorId=self.testedId,
testPrimary=not (item.text() == "X" or item.text() == "Y"),
testSecondary=not (item.text() == "P") and self.sIndex is not None,
)
self.killBumpTestButton.setText(f"Stop bump test FA ID {self.testedId}")
@asyncSlot()
async def issueCommandKillBumpTest(self):
"""Kill bump test."""
self.actuatorsTable.setRangeSelected(
QTableWidgetSelectionRange(0, 0, self.actuatorsTable.rowCount() - 1, 11),
False,
)
await self.m1m3.remote.cmd_killForceActuatorBumpTest.start()
@Slot(map)
def detailedState(self, data):
"""Called when detailedState event is received. Intercept to enable/disable form buttons."""
if data.detailedState == MTM1M3.DetailedState.PARKEDENGINEERING:
self.bumpTestAllButton.setEnabled(True)
self.bumpTestButton.setEnabled(
self.actuatorsTable.currentItem() is not None
)
self.killBumpTestButton.setEnabled(False)
self.xIndex = self.yIndex = self.zIndex = None
else:
self.bumpTestAllButton.setEnabled(False)
self.bumpTestButton.setEnabled(False)
self.killBumpTestButton.setEnabled(False)
@Slot(map)
def appliedForces(self, data):
"""Adds applied forces to graph."""
chartData = []
if self.xIndex is not None:
chartData.append(data.xForces[self.xIndex])
if self.yIndex is not None:
chartData.append(data.yForces[self.yIndex])
if self.zIndex is not None:
chartData.append(data.zForces[self.zIndex])
self.chart.append(data.timestamp, chartData, cache_index=0)
@Slot(map)
def forceActuatorData(self, data):
"""Adds measured forces to graph."""
chartData = []
if self.xIndex is not None:
chartData.append(data.xForce[self.xIndex])
if self.yIndex is not None:
chartData.append(data.yForce[self.yIndex])
if self.zIndex is not None:
chartData.append(data.zForce[self.zIndex])
self.chart.append(data.timestamp, chartData, cache_index=1)
@asyncSlot(map)
async def forceActuatorBumpTestStatus(self, data):
"""Received when an actuator finish/start running bump tests or the actuator reports progress of the bump test."""
testProgress = [
"Not tested",
"Testing start zero",
"Testing positive",
"Positive wait zero",
"Testing negative",
"Negative wait zero",
"Passed",
"Failed",
]
# test progress
if self.zIndex is not None:
self.primaryPB.setEnabled(True)
val = data.primaryTest[self.zIndex]
self.primaryPB.setFormat(f"ID {self.testedId} - {testProgress[val]} - %v")
self.primaryPB.setValue(min(6, val))
else:
self.primaryPB.setEnabled(False)
if self.sIndex is not None:
self.secondaryPB.setEnabled(True)
val = data.secondaryTest[self.sIndex]
self.secondaryPB.setFormat(f"ID {self.testedId} - {testProgress[val]} - %v")
self.secondaryPB.setValue(min(6, val))
else:
self.secondaryPB.setEnabled(False)
# list display
for index in range(156):
actuatorId = FATABLE[index][FATABLE_ID]
row = (actuatorId % 100) - 1
colOffset = 3 * (int(actuatorId / 100) - 1)
def getColor(value):
if value == 6:
return Qt.green
elif value == 7:
return Qt.red
elif not (value == 0):
return Qt.magenta
return Qt.transparent
pColor = getColor(data.primaryTest[index])
self.actuatorsTable.item(row, colOffset + 1).setBackground(pColor)
sIndex = FATABLE[index][FATABLE_SINDEX]
if sIndex is not None:
sColor = getColor(data.secondaryTest[sIndex])
self.actuatorsTable.item(row, colOffset + 2).setBackground(sColor)
if pColor == sColor:
self.actuatorsTable.item(row, colOffset).setBackground(pColor)
else:
self.actuatorsTable.item(row, colOffset).setBackground(pColor)
# no tests running..
if data.actuatorId < 0:
selected = self.actuatorsTable.selectedItems()
if len(selected) > 0:
await self._testItem(selected[0])
elif self._testRunning:
self.bumpTestAllButton.setEnabled(True)
self.bumpTestButton.setEnabled(
self.actuatorsTable.currentItem() is not None
and self._anyCylinder()
)
self.killBumpTestButton.setEnabled(False)
self.xIndex = self.yIndex = self.zIndex = None
self.m1m3.appliedForces.disconnect(self.appliedForces)
self.m1m3.forceActuatorData.disconnect(self.forceActuatorData)
self._testRunning = False
elif self._testRunning is False:
self.bumpTestButton.setEnabled(False)
self.killBumpTestButton.setEnabled(True)
self.m1m3.appliedForces.connect(self.appliedForces)
self.m1m3.forceActuatorData.connect(self.forceActuatorData)
self._testRunning = True
# helper functions. Helps correctly enable/disable Run bump test button.
def _anyCylinderRunning(self):
return self._testRunning is True and self._anyCylinder()
def _anyCylinder(self):
return len(self.actuatorsTable.selectedItems()) > 0
class Window(QWidget):
def __init__(self):
super().__init__()
# ----------style-------------
self.font_type = "Arial"
self.font_size = 10
self.font_color = "#676767"
self.font_size2 = 12
self.font_color_black = "#f0f0f0"
#---------------------------------
self.text8 = QTextEdit()
self.text8.setReadOnly(True)
self.check_text = False
self.gbox6 = QGroupBox()
try:
f = open("plotter.txt", "x+")
except:
f = open("plotter.txt", "r")
self.s = f.readline()
f.close
if self.s == "":
f = open("plotter.txt", "w")
f.write("dark")
f.close()
self.s = "dark"
self.information_dialog()
else:
self.gbox6.setStyleSheet(
"border:None;background-color:rgba(255,255,255,0)")
self.text8.setStyleSheet(
"border:None;background-color:rgba(255,255,255,0)")
self.gbox6.setTitle("")
self.text8.setText("")
np.seterr(invalid='raise')
self.setWindowTitle("XGrapher")
self.setGeometry(500, 400, 900, 600)
self.setMinimumSize(900, 600)
pg.setConfigOption('background', (255, 255, 255, 0))
self.pw = pg.PlotWidget()
self.pw.setXRange(0, 1)
self.pw.setYRange(0, 1)
self.pw.hideButtons()
#---------------------------
self.list_errors = []
# --------------------------
self.a = False
self.b = False
self.c = False
# -------------------------
self.d = False
self.e = False
self.f = False
self.g = False
self.after = False
# -------------------------
self.check1 = False
self.check2 = False
self.check3 = False
self.check_dot = False
self.check_neg = False
self.check_xrange = False
self.check_yrange = False
# ------------Labels-----------------------------------------
self.label1 = QLabel()
self.label1.setText("F(x):")
self.label2 = QLabel()
self.label2.setText("Min(x):")
self.label3 = QLabel()
self.label3.setText("Max(x):")
self.label4 = QLabel()
self.label5 = QLabel()
self.label5.setText("< x <")
self.label6 = QLabel()
self.label6.setText("< y <")
# --------------------------texteditors------------------
self.text1 = QLineEdit(self)
self.text1.textChanged.connect(self.text1_response)
self.text1.returnPressed.connect(self.focus_text1)
self.text2 = QLineEdit(self)
self.text2.textChanged.connect(self.text2_response)
self.text2.returnPressed.connect(self.focus_text2)
self.text3 = QLineEdit(self)
self.text3.textChanged.connect(self.text3_response)
self.text3.returnPressed.connect(self.focus_text3)
self.text4 = QLineEdit()
self.text4.textChanged.connect(self.text4_response)
self.text4.returnPressed.connect(self.focus_text4)
self.text5 = QLineEdit()
self.text5.textChanged.connect(self.text5_response)
self.text5.returnPressed.connect(self.focus_text5)
self.text6 = QLineEdit()
self.text6.textChanged.connect(self.text6_response)
self.text6.returnPressed.connect(self.focus_text6)
self.text7 = QLineEdit()
self.text7.textChanged.connect(self.text7_response)
self.text7.returnPressed.connect(self.focus_text7)
# --------------------------------------------------------
self.button_2 = QPushButton()
self.button_2.clicked.connect(self.auto_mode)
self.button_save = QPushButton("Export Graph")
self.button_help = QPushButton()
self.button_help.clicked.connect(self.information_dialog)
# ----------------------RadioButtons----------------------
self.rbutton1 = QRadioButton("Light")
self.rbutton1.toggled.connect(self.light_mode)
self.rbutton2 = QRadioButton("Dark")
self.rbutton2.toggled.connect(self.dark_mode)
# --------------------------------------------------------
self.setIcon()
self.center()
self.input_box()
self.plot_box()
self.vbox = QHBoxLayout()
self.vbox.addWidget(self.gbox5)
self.vbox.addSpacing(5)
self.vbox.addWidget(self.plot)
# self.setStyleSheet("background-color:rgb(32,32,32);")
# self.setStyleSheet("background-color:rgb(240,240,240);")
self.setLayout(self.vbox)
if self.s == "dark":
self.rbutton2.setChecked(True)
else:
self.rbutton1.setChecked(True)
if self.s == "dark":
self.dark_mode()
else:
self.light_mode()
self.show()
# --------------------------------------evalute-------------------------------------------------------------------
self.replacements = {
'sin': 'np.sin',
'cos': 'np.cos',
'tan': 'np.tan',
'arccos': 'np.arccos',
'arcsin': 'np.arcsin',
'arctan': 'np.arctan',
'exp': 'np.exp',
'sqrt': 'np.sqrt',
'cbrt': 'np.cbrt',
'ln': 'np.log',
"cosh": "np.cosh",
"sinh": "np.cosh",
"tanh": "np.cosh"
}
self.allowed_words = [
"x", "sin", "cos", "tan", "arccos", "arcsin", "arctan", "cosh",
"sinh", "tanh", "exp", "sqrt", "cbrt", "log10", "ln"
]
# ----------------------------------------------------------------------------------------------------------------
self.after = True
def setIcon(self):
appIcon = QIcon("close.ico")
self.setWindowIcon(appIcon)
def center(self):
qRect = self.frameGeometry()
centerPoint = QDesktopWidget().availableGeometry().center()
qRect.moveCenter(centerPoint)
self.move(qRect.topLeft())
def input_box(self):
self.input = QGroupBox("Function")
self.gbox = QGroupBox("Range")
vbox_parent = QVBoxLayout()
self.hbox_parent = QVBoxLayout()
hbox1 = QHBoxLayout()
hbox2 = QHBoxLayout()
hbox3 = QHBoxLayout()
hbox1.addWidget(self.label1)
hbox1.addSpacing(17)
hbox1.addWidget(self.text1)
hbox2.addWidget(self.label2)
hbox2.addSpacing(4)
hbox2.addWidget(self.text2)
hbox3.addWidget(self.label3)
hbox3.addSpacing(0)
hbox3.addWidget(self.text3)
hbox_button = QHBoxLayout()
hbox_button.addStretch(1)
self.button = QPushButton("Reset")
self.button.setFixedSize(70, 25)
self.button.clicked.connect(self.reset)
hbox_button.addWidget(self.button)
vbox_parent.addLayout(hbox1)
vbox_parent.addLayout(hbox2)
vbox_parent.addLayout(hbox3)
vbox_parent.addLayout(hbox_button)
self.input.setLayout(vbox_parent)
hbox4 = QHBoxLayout()
hbox4.addWidget(self.text4)
hbox4.addWidget(self.label5)
hbox4.addWidget(self.text5)
hbox5 = QHBoxLayout()
hbox5.addWidget(self.text6)
hbox5.addWidget(self.label6)
hbox5.addWidget(self.text7)
vbox3 = QVBoxLayout()
vbox3.addWidget(self.button_2)
vbox2 = QVBoxLayout()
vbox2.addLayout(hbox4)
vbox2.addLayout(hbox5)
hbox6 = QHBoxLayout()
hbox6.addLayout(vbox2)
hbox6.addLayout(vbox3)
self.gbox.setLayout(hbox6)
#self.button_save.setFixedSize(200, 25)
self.button_save.setFixedHeight(25)
self.button_save.setFixedWidth(220)
self.button_save.clicked.connect(self.export)
hbox7 = QHBoxLayout()
hbox7.addWidget(self.button_save)
hbox7.addWidget(self.button_help)
self.gbox3 = QGroupBox()
self.gbox3.setFlat(True)
self.gbox3.setStyleSheet("border: None")
#self.gbox3.setLayout(hbox7)
vbox3 = QVBoxLayout()
vbox3.addWidget(self.gbox)
self.gbox4 = QGroupBox("Status")
hbox8 = QHBoxLayout()
hbox8.addWidget(self.label4)
self.gbox4.setLayout(hbox8)
self.gbox_mode = QGroupBox("Style")
vbox4 = QHBoxLayout()
vbox4.addWidget(self.rbutton1)
vbox4.addWidget(self.rbutton2)
self.gbox_mode.setLayout(vbox4)
hbox9 = QHBoxLayout()
hbox9.addWidget(self.text8)
self.gbox6.setLayout(hbox9)
self.hbox_parent.addWidget(self.input)
self.hbox_parent.addLayout(vbox3)
self.hbox_parent.addLayout(hbox7)
self.hbox_parent.addWidget(self.gbox6)
self.hbox_parent.addWidget(self.gbox_mode)
self.hbox_parent.addWidget(self.gbox4)
self.gbox5 = QGroupBox()
self.gbox5.setLayout(self.hbox_parent)
def plot_box(self):
self.plot = QGroupBox()
layout = QVBoxLayout()
self.pw.showGrid(True, True, 0.5)
layout.addWidget(self.pw)
self.plot.setLayout(layout)
def text_restricted(self, str):
if str != "":
word = str[len(str) - 1]
if re.match('[0-9-.]', word) is None:
k = str.translate({ord(word): None})
str = k
if word == "-" and len(str) > 1:
k = str[1:].translate({ord(word): None})
str = str.replace(str[1:], k)
if word == ".":
i = 0
for v in str:
if v == ".":
i += 1
if i > 1:
str = str[0:len(str) - 1] + ""
if word == ".":
self.check_dot = True
else:
str = ""
return str
def text1_response(self):
if self.check1 == False:
self.a = True
self.plotx()
else:
self.check1 = False
def text2_response(self):
self.text2.setText(self.text_restricted(self.text2.text()))
if self.check2 == False:
self.b = True
self.plotx()
else:
self.check2 = False
def text3_response(self):
self.text3.setText(self.text_restricted(self.text3.text()))
if self.check3 == False:
self.c = True
self.plotx()
else:
self.check3 = False
def text4_response(self):
self.text4.setText(self.text_restricted(self.text4.text()))
self.xrange()
def text5_response(self):
self.text5.setText(self.text_restricted(self.text5.text()))
self.xrange()
def text6_response(self):
self.text6.setText(self.text_restricted(self.text6.text()))
self.yrange()
def text7_response(self):
self.text7.setText(self.text_restricted(self.text7.text()))
self.yrange()
def xrange(self):
if self.text4.text() == "" and self.text5.text() == "":
self.error("No X Min Range")
self.error("No X Max Range")
self.error("Invalid X Range")
self.f = False
self.check_xrange = False
if self.text1.text() == "" or self.text2.text(
) == "" or self.text3.text() == "":
self.pw.setXRange(0, 1)
else:
self.pw.enableAutoRange(axis='x')
elif self.text4.text() != "" and self.text5.text() != "":
self.check_xrange = True
if float(self.text4.text()) >= float(self.text5.text()):
self.error_add("Invalid X Range")
self.f = True
else:
self.pw.setXRange(float(self.text4.text()),
float(self.text5.text()))
self.error("No X Min Range")
self.error("No X Max Range")
self.error("Invalid X Range")
self.f = False
self.plotx()
if self.text6.text() == "" or self.text7.text() == "":
self.pw.enableAutoRange(axis='y')
self.pw.setAutoVisible(y=True)
else:
if self.text4.text() == "" and self.check_xrange == True:
self.error_add("No X Min Range")
self.f = True
self.pw.setXRange(0, 1)
if self.text5.text() == "" and self.check_xrange == True:
self.error_add("No X Max Range")
self.f = True
self.pw.setXRange(0, 1)
if self.text6.text() != "" and self.text7.text() != "":
self.pw.enableAutoRange(axis='x')
self.pw.setAutoVisible(x=True)
else:
if self.d == True or self.e == True:
self.pw.setYRange(0, 1)
self.pw.setXRange(0, 1)
else:
self.pw.enableAutoRange()
def yrange(self):
if self.text6.text() == "" and self.text7.text() == "":
self.error("No Y Min Range")
self.error("No Y Max Range")
self.error("Invalid Y Range")
self.g = False
self.check_yrange = False
if self.text1.text() == "" or self.text2.text(
) == "" or self.text3.text() == "":
self.pw.setYRange(0, 1)
else:
self.pw.enableAutoRange(axis='y')
elif self.text6.text() != "" and self.text7.text() != "":
self.check_yrange = True
if float(self.text6.text()) >= float(self.text7.text()):
self.error_add("Invalid Y Range")
self.g = True
else:
self.pw.setYRange(float(self.text6.text()),
float(self.text7.text()))
self.error("No Y Min Range")
self.error("No Y Max Range")
self.error("Invalid Y Range")
self.g = False
self.plotx()
if self.text4.text() == "" or self.text5.text() == "":
self.pw.enableAutoRange(axis='x')
self.pw.setAutoVisible(x=True)
else:
if self.text6.text() == "" and self.check_yrange == True:
self.error_add("No Y Min Range")
self.g = True
self.pw.setYRange(0, 1)
if self.text7.text() == "" and self.check_yrange == True:
self.error_add("No Y Max Range")
self.g = True
self.pw.setYRange(0, 1)
if self.text4.text() != "" and self.text5.text() != "":
self.pw.enableAutoRange(axis='y')
self.pw.setAutoVisible(y=True)
else:
if self.d == True or self.e == True:
self.pw.setYRange(0, 1)
self.pw.setXRange(0, 1)
else:
self.pw.enableAutoRange()
def string2func(self, str):
if str != "" and self.a == True and self.b == True and self.c == True:
self.error("No Function to draw")
self.d = False
for word in re.findall('[a-zA-Z_]+', str):
if word not in self.allowed_words:
self.error_add("F(x) is not a Function of x")
self.d = True
else:
self.d = False
self.error('F(x) is not a Function of x')
if word in self.replacements:
str = str.replace(word, self.replacements[word])
if "^" in str:
str = str.replace("^", "**")
elif str == "" and self.b == True and self.c == True:
self.error_add("No Function to draw")
self.d = True
self.pw.clear()
def func(x):
if str != "" and self.text2.text() != "" and self.text3.text(
) != "" and self.d == False:
if self.d == False:
try:
if np.inf in eval(str):
raise ZeroDivisionError
if -np.inf in eval(str):
raise ValueError
except ZeroDivisionError:
self.error_add("Cannot divide by Zero")
self.d = True
except FloatingPointError:
self.error_addd("Undefined")
self.d = True
except ValueError:
self.error_add("Math Error")
self.d = True
except:
self.error_add("Syntax Error")
self.d = True
else:
self.error("Cannot divide by Zero")
self.error("Undefined")
self.error("Math Error")
self.error("Syntax Error")
self.d = False
return eval(str)
return func
def plotx(self):
if self.text2.text() == "" and self.text3.text(
) == "" and self.text1.text(
) == "" and self.a == True and self.b == True and self.c == True:
self.reset()
func = self.string2func(self.text1.text())
if self.a == True and self.b == True and self.c == True and self.text2.text(
) != "" and self.text3.text() != "" and self.text1.text(
) != "" and self.d == False:
if (self.text4.text() == "" and self.text5.text() == "") and (
self.text6.text() == "" and self.text7.text() == ""):
self.pw.enableAutoRange()
self.pw.clear()
if (self.text2.text() == "-" or self.text3.text() == "-"
or self.text3.text() == "." or self.text2.text() == "."):
self.list_errors.append("Invalid Range")
self.e = True
else:
min_num = float(self.text2.text())
max_num = float(self.text3.text())
if min_num >= max_num:
self.error_add("Invalid Range")
self.e = True
else:
range = np.linspace(min_num, max_num, 2000)
if "x" not in self.text1.text(
) and self.text1.text() != "":
try:
if self.s == "light":
self.pw.plot(range,
np.ones(len(range)) *
eval(self.text1.text()),
pen=pg.mkPen(color=(140, 140,
140),
width=2))
else:
self.pw.plot(range,
np.ones(len(range)) *
eval(self.text1.text()),
pen=pg.mkPen(color="w", width=2))
except ZeroDivisionError:
self.error_add("Cannot divide by Zero")
self.d = True
except FloatingPointError:
self.error_add("Undefined")
self.d = True
except ValueError:
self.error_add("Math Error")
self.d = True
except:
self.error_add("Syntax Error")
self.d = True
else:
self.error("Cannot divide by Zero")
self.error("Undefined")
self.error("Math Error")
self.error("Syntax Error")
self.d = False
else:
y = func(range)
if self.s == "light":
self.pw.plot(range,
y,
pen=pg.mkPen(color=(140, 140, 140),
width=2))
self.error("Invalid Range")
self.error("No Min Value")
self.error("No Max Value")
else:
self.pw.plot(range,
y,
pen=pg.mkPen(color="w", width=2))
self.error("Invalid Range")
self.error("No Min Value")
self.error("No Max Value")
self.e = False
else:
if (self.text3.text() == "" and self.c == True):
self.pw.clear()
self.e = True
self.error_add("No Max Value")
elif (self.text3.text() != "" and self.c == True):
self.error("No Max Value")
if (self.text2.text() == "" and self.b == True):
self.pw.clear()
self.e = True
self.error_add("No Min Value")
elif (self.text2.text() != "" and self.b == True):
self.error("No Min Value")
def error(self, type):
if type in self.list_errors:
self.list_errors.remove(type)
if len(self.list_errors) == 0:
self.label4.setText("")
else:
self.label4.setText(self.list_errors[len(self.list_errors) - 1])
def error_add(self, error):
if error in self.list_errors:
pass
else:
self.list_errors.append(error)
self.label4.setText(self.list_errors[len(self.list_errors) - 1])
def reset(self):
self.pw.clear()
if self.text4.text() == "" and self.text5.text(
) == "" and self.text6.text() == "" and self.text7.text() == "":
self.pw.setXRange(0, 1)
self.pw.setYRange(0, 1)
self.check1 = True
self.check2 = True
self.check3 = True
self.text1.setText("")
self.text2.setText("")
self.text3.setText("")
self.a = False
self.b = False
self.c = False
self.text1.setFocus()
self.d = False
self.e = False
self.error("Invalid Range")
self.error("No Min Value")
self.error("No Max Value")
self.error("Cannot divide by Zero")
self.error("Undefined")
self.error("Math Error")
self.error("Syntax Error")
self.error('F(x) is not a Function of x')
self.error("No Function to draw")
def focus_text1(self):
self.text2.setFocus()
def focus_text2(self):
self.text3.setFocus()
def focus_text3(self):
self.text1.setFocus()
def focus_text4(self):
self.text5.setFocus()
def focus_text5(self):
self.text6.setFocus()
def focus_text6(self):
self.text7.setFocus()
def focus_text7(self):
self.text4.setFocus()
def save(self):
pass
def information_dialog(self):
if self.check_text == False:
if self.s == "dark":
self.gbox6.setTitle("Help")
self.gbox6.setStyleSheet(
"QGroupBox {border: 2px solid #3d3d3d;background-color:#383838;color: "
+ self.font_color_black + ";margin-top: 6px;}" +
"QGroupBox::title {subcontrol-origin:margin;left:8px;padding: 0px 0px 0px 0px;}"
)
self.text8.setStyleSheet(
"border:None;background-color:#383838;border:None;color: "
+ self.font_color_black)
self.text8.setFont(
QFont(self.font_type, self.font_size, QFont.Normal))
self.text8.setText("--> The following operators must be used when writting the function:\n( - + / ^ ( ) ).\n\n--> The program supports the following functions and must be written as:"
"\nsin(x),cos(x),tan(x),arccos(x),\narcsin(x),arctan(x),cosh(x),sinh(x),\ntanh(x),exp(x),sqrt(X),cbrt(x),\n"
"log10(x),ln(x) and polynomial and rational functions."
"\n\n--> The 'A' button in the Range box sets the x-axis and y-axis ranges to the appropriate values according to the values of the function.\n\n" \
"--> To close the Help box just click the help button beside the Export Graph.")
else:
self.gbox6.setTitle("Help")
self.gbox6.setStyleSheet(
"QGroupBox {border: 2px solid #e6e6e6;background-color:#f5f6f7;color: "
+ self.font_color + ";margin-top: 6px;}" +
"QGroupBox::title {subcontrol-origin:margin;left:8px;padding: 0px 0px 0px 0px;}"
)
self.text8.setStyleSheet(
"border:None;background-color:#f5f6f7;color: " +
self.font_color)
self.text8.setFont(
QFont(self.font_type, self.font_size, QFont.Normal))
self.text8.setText("--> The following operators must be used when writting the function:\n( - + / ^ ( ) ).\n\n--> The program supports the following functions and must be written as:"
"\nsin(x),cos(x),tan(x),arccos(x),\narcsin(x),arctan(x),cosh(x),sinh(x),\ntanh(x),exp(x),sqrt(X),cbrt(x),\n"
"log10(x),ln(x) and polynomial and rational functions."
"\n\n--> The 'A' button in the Range box sets the x-axis and y-axis ranges to the appropriate values according to the values of the function.\n\n" \
"--> To close the Help box just click the help button beside the Export Graph.")
self.check_text = True
else:
self.gbox6.setStyleSheet(
"border:None;background-color:rgba(255,255,255,0)")
self.text8.setStyleSheet(
"border:None;background-color:rgba(255,255,255,0)")
self.text8.setText("")
self.gbox6.setTitle("")
self.check_text = False
def auto_mode(self):
self.text4.setText("")
self.text5.setText("")
self.text6.setText("")
self.text7.setText("")
self.f = False
self.g = False
self.check_yrange == False
self.check_xrange == False
self.xrange()
self.yrange()
def dark_mode(self):
self.input.setMaximumWidth(250)
self.input.setFixedSize(250, 150)
self.gbox.setMaximumWidth(250)
self.gbox.setFixedSize(250, 90)
self.gbox3.setMaximumWidth(250)
self.gbox3.setFixedSize(250, 90)
self.gbox4.setMaximumWidth(250)
self.gbox4.setFixedSize(250, 45)
self.gbox_mode.setMaximumWidth(250)
self.gbox_mode.setFixedSize(250, 50)
self.gbox5.setMaximumWidth(270)
self.input.setObjectName("input")
self.input.setStyleSheet(
"QGroupBox#input{border: 2px solid #3d3d3d;background-color:#383838;color: "
+ self.font_color_black + ";margin-top: 6px;}" +
"QGroupBox#input::title {subcontrol-origin:margin;left:8px;padding: 0px 0px 0px 0px;}"
)
self.gbox.setStyleSheet(
"QGroupBox {border: 2px solid #3d3d3d;background-color:#383838;color: "
+ self.font_color_black + ";margin-top: 6px;}" +
"QGroupBox::title {subcontrol-origin:margin;left:8px;padding: 0px 0px 0px 0px;}"
)
self.gbox4.setStyleSheet(
"QGroupBox {border: 2px solid #3d3d3d;background-color:#383838;color: "
+ self.font_color_black + ";margin-top: 6px;}" +
"QGroupBox::title {subcontrol-origin:margin;left:8px;padding: 0px 0px 0px 0px;}"
)
self.gbox_mode.setStyleSheet(
"QGroupBox {border: 2px solid #3d3d3d;background-color:#383838;color: "
+ self.font_color_black + ";margin-top: 6px;}" +
"QGroupBox::title {subcontrol-origin:margin;left:8px;padding: 0px 0px 0px 0px;}"
)
self.plot.setStyleSheet("color: " + self.font_color)
self.setStyleSheet("background-color:#202020")
self.label1.setStyleSheet(
"background-color:#383838;border:None;color: " +
self.font_color_black)
self.label2.setStyleSheet(
"background-color:#383838;border:None;color:" +
self.font_color_black)
self.label3.setStyleSheet(
"background-color:#383838;border:None;color:" +
self.font_color_black)
self.label4.setStyleSheet(
"background-color:#383838;border:None;color:" +
self.font_color_black)
self.label5.setStyleSheet(
"background-color:#383838;border:None;color:" +
self.font_color_black)
self.label6.setStyleSheet(
"background-color:#383838;border:None;color:" +
self.font_color_black)
self.rbutton1.setStyleSheet("background-color:#383838;color:" +
self.font_color_black)
self.rbutton2.setStyleSheet("background-color:#383838;color:" +
self.font_color_black)
self.rbutton1.setFont(
QFont(self.font_type, self.font_size, QFont.Normal))
self.rbutton2.setFont(
QFont(self.font_type, self.font_size, QFont.Normal))
self.label1.setFont(QFont(self.font_type, self.font_size,
QFont.Normal))
self.label2.setFont(QFont(self.font_type, self.font_size,
QFont.Normal))
self.label3.setFont(QFont(self.font_type, self.font_size,
QFont.Normal))
self.label4.setFont(QFont(self.font_type, self.font_size,
QFont.Normal))
self.label5.setFont(QFont(self.font_type, self.font_size,
QFont.Normal))
self.label6.setFont(QFont(self.font_type, self.font_size,
QFont.Normal))
self.text1.setStyleSheet(
"border:1px solid #5b5b5b;background-color:#383838;color:" +
self.font_color_black)
self.text2.setStyleSheet(
"border:1px solid #5b5b5b;background-color:#383838;color:" +
self.font_color_black)
self.text3.setStyleSheet(
"border:1px solid #5b5b5b;background-color:#383838;color:" +
self.font_color_black)
self.text4.setStyleSheet(
"border:1px solid #5b5b5b;background-color:#383838;color:" +
self.font_color_black)
self.text5.setStyleSheet(
"border:1px solid #5b5b5b;background-color:#383838;color:" +
self.font_color_black)
self.text6.setStyleSheet(
"border:1px solid #5b5b5b;background-color:#383838;color:" +
self.font_color_black)
self.text7.setStyleSheet(
"border:1px solid #5b5b5b;background-color:#383838;color:" +
self.font_color_black)
self.button_save.setStyleSheet(
" QPushButton{border: 1px solid #f0f0f0;Text-align:center;background:#333333; color:#f0f0f0}"
"QPushButton::hover{border: 1px solid #f0f0f0;Text-align:center;background:#2c2c2c}"
"QPushButton::Pressed{border: 1px solid #f0f0f0;Text-align:center;background:#3d3c3c}"
)
self.button.setStyleSheet(
" QPushButton{border: 1px solid #f0f0f0;Text-align:center;background:#333333; color:#f0f0f0}"
"QPushButton::hover{border: 1px solid #f0f0f0;Text-align:center;background:#2c2c2c}"
"QPushButton::Pressed{border: 1px solid #f0f0f0;Text-align:center;background:#3d3c3c}"
)
self.text1.setFont(QFont(self.font_type, self.font_size, QFont.Normal))
self.text2.setFont(QFont(self.font_type, self.font_size, QFont.Normal))
self.text3.setFont(QFont(self.font_type, self.font_size, QFont.Normal))
self.text4.setFont(QFont(self.font_type, self.font_size, QFont.Normal))
self.text5.setFont(QFont(self.font_type, self.font_size, QFont.Normal))
self.text6.setFont(QFont(self.font_type, self.font_size, QFont.Normal))
self.text7.setFont(QFont(self.font_type, self.font_size, QFont.Normal))
self.gbox5.setObjectName("GroupBox")
self.gbox5.setStyleSheet(
"QGroupBox#GroupBox{border: None;background-color:#383838}")
f = open("plotter.txt", "w")
f.write("dark")
f.close()
self.s = "dark"
self.pw.setBackground(background=None)
if self.after == True:
self.plotx()
pixmap1 = QPixmap("auto-button_dark.png")
button_icon1 = QIcon(pixmap1)
self.button_2.setStyleSheet("border:none;background-color:#383838")
self.button_2.setIcon(button_icon1)
pixmap2 = QPixmap("help_dark.png")
button_icon2 = QIcon(pixmap2)
self.button_help.setIcon(button_icon2)
self.button_help.setStyleSheet("border:none;background-color:#383838")
if self.check_text == True:
self.gbox6.setStyleSheet(
"QGroupBox {border: 2px solid #3d3d3d;background-color:#383838;color: "
+ self.font_color_black + ";margin-top: 6px;}" +
"QGroupBox::title {subcontrol-origin:margin;left:8px;padding: 0px 0px 0px 0px;}"
)
self.text8.setStyleSheet(
"border:None;background-color:#383838;border:None;color: " +
self.font_color_black)
self.text8.setFont(
QFont(self.font_type, self.font_size, QFont.Normal))
def light_mode(self):
self.input.setMaximumWidth(250)
self.input.setFixedSize(250, 150)
self.gbox.setMaximumWidth(250)
self.gbox.setFixedSize(250, 90)
self.gbox3.setMaximumWidth(250)
self.gbox3.setFixedSize(250, 90)
self.gbox4.setMaximumWidth(250)
self.gbox4.setFixedSize(250, 45)
self.gbox_mode.setMaximumWidth(250)
self.gbox_mode.setFixedSize(250, 50)
self.gbox5.setMaximumWidth(270)
self.input.setObjectName("input")
self.input.setStyleSheet(
"QGroupBox#input{border: 2px solid #e6e6e6;background-color:#f5f6f7;color: "
+ self.font_color + ";margin-top: 6px;}" +
"QGroupBox#input::title {subcontrol-origin:margin;left:8px;padding: 0px 0px 0px 0px;}"
)
self.gbox.setStyleSheet(
"QGroupBox {border: 2px solid #e6e6e6;background-color:#f5f6f7;color: "
+ self.font_color + ";margin-top: 6px;}" +
"QGroupBox::title {subcontrol-origin:margin;left:8px;padding: 0px 0px 0px 0px;}"
)
self.gbox4.setStyleSheet(
"QGroupBox {border: 2px solid #e6e6e6;background-color:#f5f6f7;color: "
+ self.font_color + ";margin-top: 6px;}" +
"QGroupBox::title {subcontrol-origin:margin;left:8px;padding: 0px 0px 0px 0px;}"
)
self.gbox_mode.setStyleSheet(
"QGroupBox {border: 2px solid #e6e6e6;background-color:#f5f6f7;color: "
+ self.font_color + ";margin-top: 6px;}" +
"QGroupBox::title {subcontrol-origin:margin;left:8px;padding: 0px 0px 0px 0px;}"
)
self.plot.setStyleSheet("color: " + self.font_color)
self.setStyleSheet("background-color:white;")
self.label1.setStyleSheet("background-color:#f5f6f7;color: " +
self.font_color)
self.label2.setStyleSheet("background-color:#f5f6f7;color:" +
self.font_color)
self.label3.setStyleSheet("background-color:#f5f6f7;color:" +
self.font_color)
self.label4.setStyleSheet("background-color:#f5f6f7;color:" +
self.font_color)
self.label5.setStyleSheet("background-color:#f5f6f7;color:" +
self.font_color)
self.label6.setStyleSheet("background-color:#f5f6f7;color:" +
self.font_color)
self.rbutton1.setStyleSheet("background-color:#f5f6f7;color:" +
self.font_color)
self.rbutton2.setStyleSheet("background-color:#f5f6f7;color:" +
self.font_color)
self.rbutton1.setFont(
QFont(self.font_type, self.font_size, QFont.Normal))
self.rbutton2.setFont(
QFont(self.font_type, self.font_size, QFont.Normal))
self.label1.setFont(QFont(self.font_type, self.font_size,
QFont.Normal))
self.label2.setFont(QFont(self.font_type, self.font_size,
QFont.Normal))
self.label3.setFont(QFont(self.font_type, self.font_size,
QFont.Normal))
self.label4.setFont(QFont(self.font_type, self.font_size,
QFont.Normal))
self.label5.setFont(QFont(self.font_type, self.font_size,
QFont.Normal))
self.label6.setFont(QFont(self.font_type, self.font_size,
QFont.Normal))
self.text1.setStyleSheet("background-color:white")
self.text2.setStyleSheet("background-color:white")
self.text3.setStyleSheet("background-color:white")
self.text4.setStyleSheet("background-color:white")
self.text5.setStyleSheet("background-color:white")
self.text6.setStyleSheet("background-color:white")
self.text7.setStyleSheet("background-color:white")
self.button_save.setStyleSheet(
" QPushButton{border: 1px solid #adadad;Text-align:center;background:#e1e1e1; color:black}"
"QPushButton::hover{border: 1px solid #adadad;Text-align:center;background:#d8d7d7}"
"QPushButton::Pressed{border: 1px solid #adadad;Text-align:center;background:#f5f6f7}"
)
self.button.setStyleSheet(
" QPushButton{border: 1px solid #adadad;Text-align:center;background:#e1e1e1; color:black}"
"QPushButton::hover{border: 1px solid #adadad;Text-align:center;background:#d8d7d7}"
"QPushButton::Pressed{border: 1px solid #adadad;Text-align:center;background:#f5f6f7}"
)
self.text1.setFont(QFont(self.font_type, self.font_size, QFont.Normal))
self.text2.setFont(QFont(self.font_type, self.font_size, QFont.Normal))
self.text3.setFont(QFont(self.font_type, self.font_size, QFont.Normal))
self.text4.setFont(QFont(self.font_type, self.font_size, QFont.Normal))
self.text5.setFont(QFont(self.font_type, self.font_size, QFont.Normal))
self.text6.setFont(QFont(self.font_type, self.font_size, QFont.Normal))
self.text7.setFont(QFont(self.font_type, self.font_size, QFont.Normal))
self.gbox5.setObjectName("GroupBox")
self.gbox5.setStyleSheet(
"QGroupBox#GroupBox{border: None;background-color:#f5f6f7}")
f = open("plotter.txt", "w")
f.write("light")
f.close()
self.s = "light"
self.pw.setBackground(background=None)
if self.after == True:
self.plotx()
pixmap2 = QPixmap("auto-button.png")
button_icon2 = QIcon(pixmap2)
self.button_2.setStyleSheet("border:none;background-color:#f5f6f7")
self.button_2.setIcon(button_icon2)
pixmap2 = QPixmap("help_light.png")
button_icon2 = QIcon(pixmap2)
self.button_help.setIcon(button_icon2)
self.button_help.setStyleSheet("border:none;background-color:#f5f6f7")
if self.check_text == True:
self.gbox6.setStyleSheet(
"QGroupBox {border: 2px solid #e6e6e6;background-color:#f5f6f7;color: "
+ self.font_color + ";margin-top: 6px;}" +
"QGroupBox::title {subcontrol-origin:margin;left:8px;padding: 0px 0px 0px 0px;}"
)
self.text8.setStyleSheet(
"border:None;background-color:#f5f6f7;color: " +
self.font_color)
self.text8.setFont(
QFont(self.font_type, self.font_size, QFont.Normal))
def export(self):
self.exportdialog = exportDialog.ExportDialog(self.pw.plotItem.scene())
name = QFileDialog.getSaveFileName(
self, 'Save File', "",
"PNG (*.PNG;*.PNG);;CSV (*.CSV);;SVG(*.SVG)", "",
QFileDialog.Options())
if name[0] != "":
if "PNG" in name[1]:
if self.s == "dark":
self.pw.setBackground(background=(0, 0, 0))
else:
self.pw.setBackground(background=(255, 255, 255))
exporter = pg.exporters.ImageExporter(self.pw.plotItem)
exporter.export(name[0])
self.pw.setBackground(background=None)
elif "CSV" in name[1]:
exporter = pg.exporters.CSVExporter(self.pw.plotItem)
exporter.export(name[0])
elif "SVG" in name[1]:
if self.s == "dark":
self.pw.setBackground(background=(0, 0, 0))
else:
self.pw.setBackground(background=(255, 255, 255))
exporter = pg.exporters.SVGExporter(self.pw.plotItem)
exporter.export(name[0])
self.pw.setBackground(background=None)
class Window(QWidget):
def __init__(self):
# call the constructor of the parent (QWidget)
super().__init__()
# check if it the first time for user to plot
self.firstTime = False
# set title and geometry for the window
self.setWindowTitle("Function Plotter")
self.setGeometry(500, 400, 400, 200)
# give orange background to the window
palette = self.palette()
palette.setColor(QPalette.Window, QColor(150, 150, 150))
self.setPalette(palette)
self.setAutoFillBackground(True)
# set minimum width and height for the window
self.setMinimumHeight(200)
self.setMinimumWidth(400)
self.setMaximumHeight(200)
self.setMaximumWidth(400)
# set icon for the application at run time and center the application window with the primary screen
self.setIcon()
self.center()
# setup the grid layout design and components
self.createGridLayout()
self.vbox = QVBoxLayout()
self.vbox.addWidget(self.groupBox)
self.vbox.setAlignment(Qt.AlignCenter | Qt.AlignTop)
self.setLayout(self.vbox)
# set icon for the application
def setIcon(self):
appIcon = QIcon("icon.png")
self.setWindowIcon(appIcon)
# reading the data from text input and apply check tests
def readData(self):
# read the equation and check if there is an actual input
equation = self.equationInput.text()
if equation == '':
self.aboutBox("Empty section", "Please enter an equation")
return
# remove spaces from the equation and check if the equation has valid variable name
equation = removeSpaces(equation)
varName, _ = getVariableName(equation)
check, error = checkVarName(equation, varName)
if not check:
self.aboutBox("Wrong equation", error)
return
# check min and max value if it's a real number and the text input isn't empty
maxValue = self.maxInput.text()
if maxValue == '':
self.aboutBox("Empty section", "Please enter maximum value")
return
try:
maxValue = float(maxValue)
except ValueError:
self.aboutBox(
"Wrong range",
"Invalid value for maximum, please enter float or integer value"
)
return
minValue = self.minInput.text()
if minValue == '':
self.aboutBox("Empty section", "Please enter minimum value")
return
try:
minValue = float(minValue)
except ValueError:
self.aboutBox(
"Wrong range",
"Invalid value for minimum, please enter float or integer value"
)
return
# the max value should be greater than min value
if minValue >= maxValue:
self.aboutBox("Wrong range",
"Your maximum value should be greater than minimum")
return
# process the equation by trying to solve it with max value and check if there is error with operatos, operands or parentheses
ops = trimTerms(equation, varName)
temp_ops = replaceVar(ops, varName, str(maxValue))
testVal, error = functionCalculator(temp_ops)
if error != None:
self.aboutBox("Evaluation error", error)
return
# function to evaluate f(x) array and return f(x) and x lists to be plotted
fx, x = self.evaluateFunction(ops, maxValue, minValue, varName)
# plot the graph
self.plotGraph(fx, x, varName)
def plotGraph(self, fx, x, varName):
# remove the old figure if user request another equation
if self.firstTime:
self.fig.clear()
self.vbox.removeWidget(self.toolbar)
self.vbox.removeWidget(self.canvas)
# set first time to be True, to remove the old figures
self.firstTime = True
# set the figure and toolbar and add it to the window
self.fig = Figure(figsize=(7, 5),
dpi=65,
facecolor=(1, 1, 1),
edgecolor=(0, 0, 0))
self.canvas = FigureCanvas(self.fig)
self.toolbar = NavigationToolbar(self.canvas, self)
self.vbox.addWidget(self.toolbar)
self.vbox.addWidget(self.canvas)
# set new geometry to the window to fit the graph
self.resize(400, 500)
self.setMinimumHeight(500)
self.setMaximumHeight(500)
# plot the graph and set the labels
self.ax = self.fig.add_subplot(111)
self.ax.plot(x, fx)
if varName == '':
varName = 'x'
self.ax.set_xlabel(varName)
self.ax.set_ylabel('f(' + varName + ')')
# QMessageBox which shows any error for the user
def aboutBox(self, title, error):
QMessageBox.about(self, title, error)
def evaluateFunction(self, ops, maxVal, minVal, varName):
# make array with start = minVal, end, maxVal and step for 0.25 for some accuracy
x = np.arange(minVal, maxVal, 0.25)
fx = []
# loop over each number(i) and evaluate f(i) then add it to f(x) list
for number in x:
temp_ops = replaceVar(ops, varName, number)
val, _ = functionCalculator(temp_ops)
fx.append(val)
return fx, x
# to center the application window at the beginning
def center(self):
qRect = self.frameGeometry()
centerPoint = QtGui.QGuiApplication.primaryScreen().availableGeometry(
).center()
qRect.moveCenter(centerPoint)
self.move(qRect.topLeft())
def createGridLayout(self):
# make group box with headline then add the gridlayout to it
self.groupBox = QGroupBox("Please fill next sections")
self.groupBox.setFont(QFont("Helvetica", 12))
self.groupBox.setMaximumWidth(400)
self.groupBox.setMaximumHeight(200)
# create gridlayout with spacing between columns and rows
gridLayout = QGridLayout()
gridLayout.setSpacing(10)
# set equation text input
self.equationInput = QLineEdit()
self.equationInput.setMaximumHeight(30)
#self.equationInput.setMaximumWidth(175)
self.equationInput.setPlaceholderText("Enter your equation")
gridLayout.addWidget(self.equationInput, 0, 0, 1, 0)
# set max value text input
self.maxInput = QLineEdit()
self.maxInput.setMaximumHeight(30)
self.maxInput.setMaximumWidth(175)
self.maxInput.setPlaceholderText("Enter maximum value")
gridLayout.addWidget(self.maxInput, 1, 0)
# set min value text input
self.minInput = QLineEdit()
self.minInput.setMaximumHeight(30)
self.minInput.setMaximumWidth(175)
self.minInput.setPlaceholderText("Enter minimum value")
gridLayout.addWidget(self.minInput, 1, 1)
# set Plot push button with green color and an icon
plotButton = QPushButton("Plot")
plotButton.setStyleSheet("background-color: green")
plotButton.setIcon(QIcon("curve.png"))
plotButton.setMaximumHeight(30)
plotButton.setMaximumWidth(75)
# when button is clicked, call readData and then will plot the function
plotButton.clicked.connect(self.readData)
gridLayout.addWidget(plotButton, 2, 0)
# add gridlayout to the group box
self.setLayout(gridLayout)
self.groupBox.setLayout(gridLayout)
class FilterDock(QDockWidget):
def __init__(self, platforms, regions, genres, years):
super(FilterDock, self).__init__()
# QDockWidget settings
self.setAllowedAreas(Qt.BottomDockWidgetArea)
self.setFeatures(QDockWidget.DockWidgetClosable)
self.setFixedHeight(150)
self.setVisible(False)
self.setWindowTitle("Filter options")
# The selected items for each widget are saved in a set-dictionary
self._selections = defaultdict(set)
# Widget settings
# Platform widgets
self._platformLabel = QLabel("Platform")
self._platforms = QListWidget()
self._platforms.addItems(platforms)
self._platforms.setSelectionMode(QAbstractItemView.MultiSelection)
self._platforms.setMaximumWidth(200)
self._platformVBox = QVBoxLayout()
self._platformVBox.addWidget(self._platformLabel, 0)
self._platformVBox.addWidget(self._platforms, 1)
# Region widgets
self._regionLabel = QLabel("Region")
self._regions = QListWidget()
self._regions.addItems(regions)
self._regions.setSelectionMode(QAbstractItemView.MultiSelection)
self._regions.setMaximumWidth(200)
self._regionVBox = QVBoxLayout()
self._regionVBox.addWidget(self._regionLabel, 0)
self._regionVBox.addWidget(self._regions, 1)
# Genre widgets
self._genreLabel = QLabel("Genre")
self._genres = QListWidget()
self._genres.addItems(genres)
self._genres.setSelectionMode(QAbstractItemView.MultiSelection)
self._genres.setMaximumWidth(300)
self._genreVBox = QVBoxLayout()
self._genreVBox.addWidget(self._genreLabel, 0)
self._genreVBox.addWidget(self._genres, 1)
# Year widgets
self._yearLabel = QLabel("Year")
self._years = QListWidget()
self._years.addItems(years)
self._years.setSelectionMode(QAbstractItemView.MultiSelection)
self._years.setMaximumWidth(75)
self._yearsVbox = QVBoxLayout()
self._yearsVbox.addWidget(self._yearLabel, 0)
self._yearsVbox.addWidget(self._years, 1)
# Inventory widgets
self._itemType = {1: "Game", 2: "Console", 3: "Accessory"}
self._item = QCheckBox(self._itemType[1])
self._item.setTristate(True)
self._item.setCheckState(Qt.PartiallyChecked)
self._manual = QCheckBox("Manual")
self._manual.setTristate(True)
self._manual.setCheckState(Qt.PartiallyChecked)
self._box = QCheckBox("Box")
self._box.setTristate(True)
self._box.setCheckState(Qt.PartiallyChecked)
self._inventoryLabelsVBox = QVBoxLayout()
self._inventorySelectionsVBox = QVBoxLayout()
self._inventorySelectionsVBox.addStretch(3)
self._inventorySelectionsVBox.addWidget(self._item, 0)
self._inventorySelectionsVBox.addWidget(self._box, 1)
self._inventorySelectionsVBox.addWidget(self._manual, 2)
self._inventorySelectionsVBox.setAlignment(Qt.AlignLeft)
self._haveHBox = QHBoxLayout()
self._haveHBox.addLayout(self._inventoryLabelsVBox, 0)
self._haveHBox.addLayout(self._inventorySelectionsVBox, 1)
self._inventoryGroup = QGroupBox("Inventory")
self._inventoryGroup.setMaximumWidth(120)
self._inventoryGroup.setLayout(self._haveHBox)
# Clear and Apply button widgets
self._clearBtn = QPushButton("Clear selection")
self._clearBtn.setMaximumSize(self._clearBtn.sizeHint())
self._clearBtn.clicked.connect(self._clearFilters)
self._btnHBox = QHBoxLayout()
self._btnHBox.setAlignment(Qt.AlignBottom | Qt.AlignRight)
self._btnHBox.addWidget(self._clearBtn, 0)
# General layout
mainHBox = QHBoxLayout()
mainHBox.setAlignment(Qt.AlignLeft)
mainHBox.addLayout(self._platformVBox, 0)
mainHBox.addLayout(self._regionVBox, 0)
mainHBox.addLayout(self._genreVBox, 0)
mainHBox.addLayout(self._yearsVbox, 0)
mainHBox.addWidget(self._inventoryGroup, 0)
mainHBox.addLayout(self._btnHBox, 0)
mainWidget = QWidget()
mainWidget.setLayout(mainHBox)
self.setWidget(mainWidget)
def _clearFilters(self):
self._platforms.clearSelection()
self._regions.clearSelection()
self._genres.clearSelection()
self._years.clearSelection()
self._item.setCheckState(Qt.PartiallyChecked)
self._box.setCheckState(Qt.PartiallyChecked)
self._manual.setCheckState(Qt.PartiallyChecked)
logger.info("Cleared all filters.")
def getSelections(self):
self._selections = defaultdict(set) # Reset selections
if len(self._platforms.selectedItems()) > 0:
platforms = [x.text() for x in self._platforms.selectedItems()]
for platform in platforms:
self._selections["Platform"].add(platform)
if len(self._regions.selectedItems()) > 0:
regions = [x.text() for x in self._regions.selectedItems()]
for region in regions:
self._selections["Region"].add(region)
if len(self._genres.selectedItems()) > 0:
genres = [x.text() for x in self._genres.selectedItems()]
for genre in genres:
self._selections["Genre"].add(genre)
if len(self._years.selectedItems()) > 0:
years = [x.text() for x in self._years.selectedItems()]
for year in years:
self._selections["Year"].add(year)
if self._item.checkState() is not Qt.PartiallyChecked:
self._selections[self._item.text()].add("Yes" if self._item.isChecked() else "No")
if self._manual.checkState() is not Qt.PartiallyChecked:
self._selections["Manual"].add("Yes" if self._manual.isChecked() else "No")
if self._box.checkState() is not Qt.PartiallyChecked:
self._selections["Box"].add("Yes" if self._box.isChecked() else "No")
return self._selections
def setItemType(self, itemType: int):
if 0 < itemType < 4:
if self._item.text() in self._selections:
# Delete previous item entry so we don't search for the wrong type in the wrong table
del self._selections[self._item.text()]
self._item.setText(self._itemType[itemType])
def toggleVisibility(self):
self.setVisible(False if self.isVisible() else True)
def updatePlatforms(self, platforms):
self._platforms.clear()
self._platforms.addItems(platforms)
logger.info("Updated platforms list.")
def updateRegions(self, regions):
self._regions.clear()
self._regions.addItems(regions)
logger.info("Updated regions list.")
def updateGenres(self, genres):
self._genres.clear()
self._genres.addItems(genres)
logger.info("Updated genres list.")
def updateYears(self, years):
self._years.clear()
self._years.addItems(years)
logger.info("Updated years list.")