class WindowController(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle(
"Spongo - Projet M1 ISEN Yncréa Brest | Margaux DOUDET et Alexandre THOMAS"
)
self.setFixedSize(1280, 720)
self.setWindowIcon(QIcon(":/img/spongo_icon.png"))
self.stacked_widget = QStackedWidget()
self.stacked_widget.setObjectName("page-container")
self.setCentralWidget(self.stacked_widget)
self._widgets = {
"/menu": MenuController(),
"/parameters": ParametersController(),
"/analysis": AnalysisController(),
"/history": HistoryController()
}
for w in self._widgets.values():
self.stacked_widget.addWidget(w)
w.changeWidget.connect(self._route)
self._route("/menu")
self.show()
def closeEvent(self, event: QCloseEvent):
ask_exit = self.stacked_widget.currentWidget().askExit()
if ask_exit:
event.accept()
else:
event.ignore()
@Slot(str, object)
def _route(self, route_name: str, parameters: object = None):
next_widget = None
for r, w in self._widgets.items():
if r == route_name:
next_widget = w
break
if next_widget is None:
print("[WARNING] Unknown widget : %s" % str(next_widget))
return
current_widget = self.stacked_widget.currentWidget()
current_widget.stop()
self.stacked_widget.setCurrentWidget(next_widget)
if route_name == "/analysis":
next_widget.start(parameters[0], parameters[1])
elif route_name == "/history":
next_widget.start(parameters)
else:
next_widget.start()
class DatatypeSelector(QGroupBox):
def __init__(self,
title: str,
datatype_to_widget,
parent: "QWidget" = None):
super().__init__(title, parent)
# Maps a datatype with its respective widget. The widget is optional
self._datatype_to_widget = datatype_to_widget
self._datatype_combobox = QComboBox()
self._stacked_widgets = QStackedWidget()
for (i, (name, datatype_factory)) in enumerate(
DataTypeContainer.providers.items()):
datatype_instance = datatype_factory()
self._datatype_combobox.addItem(name, datatype_instance)
if datatype_factory in self._datatype_to_widget:
self._stacked_widgets.insertWidget(
i, self._datatype_to_widget[datatype_factory](
datatype_instance))
self._main_layout = QVBoxLayout()
self._main_layout.addWidget(self._datatype_combobox)
self._main_layout.addWidget(self._stacked_widgets)
self.setLayout(self._main_layout)
self._datatype_combobox.currentIndexChanged[int].connect(
self._change_active_widget)
@property
def selected_datatype(self):
return self._datatype_combobox.currentData()
def change_current_datatype(self, new_datatype_dict: dict):
index = self._datatype_combobox.findText(new_datatype_dict["class"])
if index != -1:
self._datatype_combobox.setCurrentIndex(index)
self._datatype_combobox.currentData().from_dict(new_datatype_dict)
self._stacked_widgets.currentWidget().reload()
def _change_active_widget(self, index):
self._stacked_widgets.setCurrentIndex(index)
# Hide the `stacked_widgets` when the current datatype doesn't needs to display
# a widget
if self._stacked_widgets.currentIndex() != index:
self._stacked_widgets.setVisible(False)
else:
self._stacked_widgets.setVisible(True)
def to_dict(self):
return self.selected_datatype.to_dict()
class MainWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.setWindowTitle("Piano Manager")
self.setFixedSize(800, 480)
# self.showFullScreen()
# Create Page Objects Here
LogInPage = LogIn()
SignUpPage = SignUp()
InUsePage = InUse()
# Connect pages to switch each others
LogInPage.ui.ButtonRegister.clicked.connect(partial(
self.switchPage, 1))
LogInPage.ui.DButtonYes.clicked.connect(partial(self.switchPage, 2))
SignUpPage.ui.buttonHome.clicked.connect(partial(self.switchPage, 0))
InUsePage.ui.ButtonQuit.clicked.connect(partial(self.switchPage, 0))
# Insert pages into QStackedWidget
self.centralWidgets = QStackedWidget()
self.centralWidgets.addWidget(LogInPage) # index: 0
self.centralWidgets.addWidget(SignUpPage) # index: 1
self.centralWidgets.addWidget(InUsePage) # index: 2
self.setCentralWidget(self.centralWidgets)
def getCurWidget(self):
return self.centralWidgets.currentWidget()
def switchPage(self, idx):
self.getCurWidget().clearPage()
self.centralWidgets.setCurrentIndex(idx)
self.getCurWidget().setPage()
class MainWindow(QWidget):
widget_stack = None
main_widget = None
exercise_widget = None
exercise_view_widget = None
def __init__(self):
QWidget.__init__(self)
self.setup_window()
self.widget_stack.setCurrentWidget(self.main_widget)
def setup_window(self):
self.widget_stack = QStackedWidget(self)
self.main_widget = MainWidget()
self.exercise_widget = ExerciseWidget()
self.exercise_view_widget = ViewWidget()
self.widget_stack.addWidget(self.main_widget)
self.widget_stack.addWidget(self.exercise_widget)
self.widget_stack.addWidget(self.exercise_view_widget)
self.main_widget.start_exercise_file.connect(self.show_exercise_window)
self.main_widget.open_exercise_file.connect(
self.show_exercise_view_widget)
self.exercise_view_widget.return_button.clicked.connect(
self.show_main_widget)
def resizeEvent(self, event):
self.widget_stack.resize(self.size())
@Slot()
def show_main_widget(self):
if self.widget_stack.currentWidget() == self.exercise_view_widget:
self.exercise_view_widget.clear_widget()
self.widget_stack.setCurrentWidget(self.main_widget)
@Slot(str)
def show_exercise_view_widget(self, file: str):
self.widget_stack.setCurrentWidget(self.exercise_view_widget)
self.exercise_view_widget.open_exercise_file(file)
@Slot(str)
def show_exercise_window(self, file: str):
self.exercise_widget.set_file(file)
self.exercise_widget.setup_exercise()
self.exercise_widget.start()
self.widget_stack.setCurrentWidget(self.exercise_widget)
class MainWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.setWindowTitle("음취헌 Piano Manager")
self.setFixedSize(800, 480)
page_in_use = InUse()
page_log_in = LogIn()
page_sign_up = SignUp()
self.widget = QStackedWidget()
self.widget.addWidget(page_log_in) # index 0
self.widget.addWidget(page_in_use) # index 1
self.widget.addWidget(page_sign_up) # index 2
self.setCentralWidget(self.widget)
page_in_use.ui.button_quit.clicked.connect(partial(
self.switch_page, 0))
page_log_in.ui.button_register.clicked.connect(
partial(self.switch_page, 2))
page_log_in.ui.dialog_true.button_yes.clicked.connect(
partial(self.switch_page, 1))
page_sign_up.widget(4).ui.dialog_true.button_ok.clicked.connect(
partial(self.switch_page, 0))
for i in range(5):
page_sign_up.widget(i).ui.button_home.clicked.connect(
partial(self.switch_page, 0))
def switch_page(self, idx):
if idx == 1:
self.widget.widget(1).set_page(self.widget.widget(0).get_contact())
self.widget.currentWidget().clear_page()
self.widget.setCurrentIndex(idx)
else:
self.widget.currentWidget().clear_page()
self.widget.setCurrentIndex(idx)
self.widget.currentWidget().set_page()
class ExifViewer(QMainWindow):
WINDOW_SIZE = {'width': 900, 'height': 600}
def __init__(self, parent=None):
super().__init__(parent)
self.qw_tree = None
self.qw_stack = None
self.tree_type_to_stack_idx = None
self.exif_reader = None
self.setWindowTitle("exif viewer")
self.resize(self.WINDOW_SIZE['width'], self.WINDOW_SIZE['height'])
def make_viewer(self, exif_reader):
self.exif_reader = exif_reader
ifds = self.exif_reader.get_exif()
self.qw_tree = QTreeWidget(self)
qt_util_init_tree(self.qw_tree, header_list=['ifd_name'])
self.qw_stack = QStackedWidget(self)
self.tree_type_to_stack_idx = {}
for tree_item_type, (ifd_name, ifd) in enumerate(ifds.items()):
# -----------------------
# treeにifd nameを書き込んでroot_treeに登録する.
# -----------------------
qw_tree_item = QTreeWidgetItem(['{} ifd'.format(ifd_name), ''],
type=tree_item_type)
self.qw_tree.addTopLevelItem(qw_tree_item)
# -----------------------
# text_editにexif情報を書き込んでstacked_widgetに登録する.
# -----------------------
qw_text_edit = QTextEdit(self)
qt_util_init_text_edit(qw_text_edit)
qt_util_append_text_edit(qw_text_edit, None, head=True)
for _, tag in ifd.items():
qt_util_append_text_edit(qw_text_edit,
tag,
head=False,
display_max_len=50)
qt_util_reset_text_edit_cursor(qw_text_edit)
idx = self.qw_stack.addWidget(qw_text_edit)
self.tree_type_to_stack_idx[tree_item_type] = idx
else:
self.qw_tree.itemClicked.connect(self._tree_item_clicked)
# -----------------------
# widgetをlayoutに登録する.
# -----------------------
widgets = [self.qw_tree, self.qw_stack]
self._make_layout(widgets)
self._make_toolbar()
self.show() # widgetを表示する.
def _make_toolbar(self):
# action_to_text = QAction(QIcon(os.path.join('icon', 'text.png')), 'save', self)
save_icon = QApplication.style().standardIcon(
QStyle.SP_DialogSaveButton)
save_action = QAction(icon=save_icon, text='save', parent=self)
save_action.triggered.connect(self._save_text)
exit_icon = QApplication.style().standardIcon(
QStyle.SP_DialogCloseButton)
exit_action = QAction(icon=exit_icon, text='exit', parent=self)
exit_action.triggered.connect(self._quit)
# ツールバー作成
self.toolbar = self.addToolBar('tool bar')
self.toolbar.setIconSize(QSize(35, 35))
self.toolbar.setFixedHeight(35)
self.toolbar.addAction(save_action)
self.toolbar.addAction(exit_action)
def _make_layout(self, widgets):
qw_splitter = QSplitter(self)
for widget in widgets:
qw_splitter.addWidget(widget)
qw_splitter.setSizes(
[self.WINDOW_SIZE['width'] * 0.1, self.WINDOW_SIZE['width'] * 0.9])
# layout = QHBoxLayout()
# layout.addWidget(qw_splitter)
# qw = QWidget()
# qw.setLayout(layout)
# self.setCentralWidget(qw)
# self.setWindowFlags(Qt.WindowStaysOnTopHint) # 常に手前に表示する.
# MainWindowのCentral領域にWidgetを設定
self.setCentralWidget(qw_splitter)
@Slot()
def _tree_item_clicked(self, item, column):
self.qw_stack.setCurrentIndex(self.tree_type_to_stack_idx[item.type()])
current_text_edit = self.qw_stack.currentWidget()
qt_util_reset_text_edit_cursor(current_text_edit)
@Slot()
def _save_text(self):
filename = QFileDialog.getSaveFileName(self, '名前を付けて保存')
out_path = filename[0]
if out_path:
self.exif_reader.save_log(out_path)
@Slot()
def _quit(self):
qApp.quit()
# ---------------------------
# StackedWidgetに登録されたwidgetをwidgetのインスタンスで指定して表示する
# ---------------------------
import sys
from PySide2.QtWidgets import QApplication, QTextEdit, QStackedWidget
app = QApplication(sys.argv)
qw_text_edit_1 = QTextEdit()
qw_text_edit_1.append('1')
qw_text_edit_2 = QTextEdit()
qw_text_edit_2.append('2')
qw_stack = QStackedWidget()
qw_stack.addWidget(qw_text_edit_1)
qw_stack.addWidget(qw_text_edit_2)
# 表示するwidgetをwidgetのインスタンスで指定する
qw_stack.setCurrentWidget(qw_text_edit_2)
print(qw_stack.currentWidget())
qw_stack.show()
sys.exit(app.exec_())
class TTVSetsImporterWidget(QWidget):
ttv_updated = Signal(TTVSets)
def __init__(
self,
format_to_widget,
parent: "QWidget" = None,
):
super().__init__(parent)
# Components
self._ttv = None
# Maps a with its respective Widget
self._format_to_widget = format_to_widget
self._stacked_widgets = QStackedWidget()
self._name_textbox = QLineEdit("Unnamed")
self._formatter_selector = QComboBox()
for (dataset_io_name,
widget_factory) in self._format_to_widget.items():
self._formatter_selector.addItem(
dataset_io_name, getattr(DatasetIORegistry, dataset_io_name))
self._stacked_widgets.addWidget(
self._format_to_widget[dataset_io_name]())
def horizontal_line():
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
line.setFixedHeight(2)
line.setContentsMargins(0, 30, 0, 0)
return line
self._x_datatype_selector = DatatypeSelectorFactory(
title="X (Input) Datatype")
self._y_datatype_selector = DatatypeSelectorFactory(
title="Y (Output) Datatype")
datatypes_layout = QHBoxLayout()
datatypes_layout.addWidget(self._x_datatype_selector)
datatypes_layout.addWidget(self._y_datatype_selector)
self._info_layout = QFormLayout()
self._info_layout.addRow("Name", self._name_textbox)
self._info_layout.addRow("Format", self._formatter_selector)
self._main_layout = QVBoxLayout()
self._main_layout.addLayout(self._info_layout)
self._main_layout.addWidget(horizontal_line())
self._main_layout.addWidget(self._stacked_widgets)
self._main_layout.addWidget(horizontal_line())
self._main_layout.addLayout(datatypes_layout)
self._load_ttv_from_file_button = QPushButton("Load from file...")
self._load_ttv_from_file_button.clicked.connect(
self._load_ttv_from_file)
self._update_ttv_button = QPushButton("Load TTV")
self._update_ttv_button.clicked.connect(self._update_ttv)
self._button_box = QDialogButtonBox()
self._button_box.addButton(self._load_ttv_from_file_button,
QDialogButtonBox.ResetRole)
self._button_box.addButton(self._update_ttv_button,
QDialogButtonBox.ApplyRole)
self._main_layout.addWidget(self._button_box)
self.setLayout(self._main_layout)
self._formatter_selector.currentIndexChanged[int].connect(
lambda i: self._stacked_widgets.setCurrentIndex(i))
def get_ttv(self) -> "TTVSets":
return self._ttv
def _update_ttv(self):
self._ttv = self._stacked_widgets.currentWidget().load_ttv(
self._name_textbox.text(),
self._x_datatype_selector.selected_datatype,
self._y_datatype_selector.selected_datatype,
)
self.ttv_updated.emit(self._ttv)
def _load_ttv_from_file(self):
print("Loading from file...")
description_file_path = QFileDialog.getOpenFileName(
self, "Open TTV .json file")[0]
if description_file_path:
LOGGER.debug("Loading %s...", description_file_path)
ttv_dir = os.path.dirname(description_file_path)
ttv_description = TTVSetsIO.load_ttv_description(
description_file_path)
# Update name
self._name_textbox.setText(ttv_description["name"])
# Pick the new formatter
formatter_idx = self._formatter_selector.findText(
ttv_description["format"])
if formatter_idx != -1:
self._formatter_selector.setCurrentIndex(formatter_idx)
self._selected_index_changed(formatter_idx)
# TODO: Cover case when "train" is null
self._x_datatype_selector.change_current_datatype(
ttv_description["train"]["x_type"])
self._y_datatype_selector.change_current_datatype(
ttv_description["train"]["y_type"])
self._stacked_widgets.currentWidget().update_widgets(
ttv_dir, ttv_description)
self._update_ttv()
else:
LOGGER.debug("Loading cancelled")
def _selected_index_changed(self, index: int):
self._stacked_widgets.setCurrentIndex(index)
def sizeHint(self) -> "QSize":
"""Optimal size of the widget."""
return QSize(450, 150)
def __reduce__(self):
return (
TTVSetsImporterWidget,
(self._ttv_sets_dialog, None),
)
class Window(QMainWindow, WindowMenu, Plots):
def __init__(self, parent=None):
super(Window, self).__init__(parent)
self.setWindowTitle("Leak Detection Evaluation Form")
self.main_style_qss = "Eclippy.qss"
self._main_widget = QWidget(self)
self._main_layout = QVBoxLayout(self._main_widget)
self._form_widget = QWidget(self)
self._form_layout = QVBoxLayout(self._form_widget)
self._database_widget = QWidget(self)
self._database_layout = QVBoxLayout(self._database_widget)
self._database_table_label = QLabel()
self._database_table_label.setObjectName("dbtablelabel")
self._database_table_label.setStyleSheet(
'QLabel[objectName^="dbtablelabel"] {font-size: 12pt; font-weight: bold;}'
)
self._database_table_export_button = QPushButton("Export Table (CSV)")
self._database_table_export_button.clicked.connect(
self.exportDatabaseTable)
database_table_export_row = QWidget()
database_table_export_lay = QHBoxLayout(database_table_export_row)
database_table_export_lay.setContentsMargins(0, 0, 0, 0)
database_table_export_lay.addWidget(HorizontalFiller())
database_table_export_lay.addWidget(self._database_table_export_button)
self._database_layout.addWidget(self._database_table_label)
self._database_table = DataTable(use_max_height=False)
self._database_layout.addWidget(self._database_table)
self._database_layout.addWidget(database_table_export_row)
self._main_tabs = QTabWidget(self)
self._main_layout.addWidget(self._main_tabs)
self._main_tabs.addTab(self._form_widget, "Form")
self._main_tabs.addTab(self._database_widget, "Database")
snwa_logo = QPixmap("snwa_logo.png")
self._logo = QLabel(self)
self._logo.setPixmap(snwa_logo)
search_row = QWidget(self)
search_lay = QHBoxLayout(search_row)
search_lay.addWidget(self._logo)
self._search_toolbar = QToolBar(self)
self._new_rec_button = QPushButton("Create New Record")
self._new_rec_button.clicked.connect(self.createNewRecord)
self._new_rec_button.setIcon(QIcon(QPixmap("plus.png")))
self._search_toolbar.addWidget(self._new_rec_button)
# Database
DB_LOC = "LeakDetectionDatabase.db"
self._database = SQLiteLib(DB_LOC)
self.setTabs()
Plots.__init__(self)
self._data_table_label = QLabel("Client Table")
self._data_table = DataTable(1, 1, self)
search_bars = self.setSearchBars()
search_bars.setContentsMargins(0, 0, 0, 0)
search_lay.setContentsMargins(0, 0, 0, 0)
search_lay.addWidget(search_bars)
search_lay.addWidget(HorizontalFiller(self))
self.readDataFromDatabase()
self._ap_phase_widget = Client.AP_PHASE_ID.value
self._address_widget = Client.ADDRESS.value
self._main_tabs.currentChanged.connect(self.mainTabChange)
self._ap_phase_widget.returnPressed.connect(
self.checkApPhaseIDsInDatabase)
# Layout -----------------------------------
# Docks
self._form_menu_dock = QDockWidget("Form Selections", self)
self._form_menu_dock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
self._form_menu_dock.setFeatures(self._form_menu_dock.features()
& ~QDockWidget.DockWidgetClosable)
self._form_menu_dock.setWidget(self._form_menu)
self.addDockWidget(Qt.LeftDockWidgetArea, self._form_menu_dock)
self._plot_menu_dock = QDockWidget(
"Plotted Data (Double Click to Activate Chart)", self)
self._plot_menu_dock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
self._plot_menu_dock.setWidget(self._plot_menu)
self.addDockWidget(Qt.RightDockWidgetArea, self._plot_menu_dock)
WindowMenu.__init__(self)
# Tabs
form_area = QWidget(self)
form_lay = QVBoxLayout(form_area)
form_lay.addWidget(search_row)
form_lay.addWidget(self._search_toolbar)
form_lay.addWidget(BreakLine(self))
form_lay.addWidget(self._tab_label)
form_lay.addWidget(self._tabs)
form_lay.addWidget(self._data_table_label)
form_lay.addWidget(self._data_table)
form_lay.setContentsMargins(0, 0, 0, 0)
self._form_layout.addWidget(form_area)
self.updateDataTable()
self.setCentralWidget(self._main_widget)
def closeEvent(self, event):
for plot_name in self._plots:
if self._plots[plot_name].isVisible():
self._plots[plot_name].close()
if self._search_window != None and self._search_window.isVisible():
self._search_window.close()
def setSearchBars(self):
self._database.openDatabase()
self._search_apPhase_combo = ExtendedComboBox(self)
self._search_address_combo = ExtendedComboBox(self)
search_data = getAddresses(
self._database.getValuesFrom2Fields(Tables.CLIENT.name,
Client.ADDRESS.name,
Client.AP_PHASE_ID.name))
self._search_ap_phase_ids = [value[1] for value in search_data]
search_addresses = [value[0] for value in search_data]
self._search_apPhase_combo.addItems(self._search_ap_phase_ids)
self._search_address_combo.addItems(search_addresses)
self._search_apPhase_combo.currentIndexChanged.connect(
self.apPhaseComboChange)
self._search_apPhase_combo.currentTextChanged.connect(
self.newSearchApCombo)
self._search_address_combo.currentIndexChanged.connect(
self.addressComboChange)
self._search_address_combo.currentTextChanged.connect(
self.newSearchAdrCombo)
self._new = False
self._ap_phase_change = False
self._address_change = False
self._database.closeDatabase()
bot_menu = QWidget(self)
bot_menu_layout = QFormLayout(bot_menu)
bot_menu.setStyleSheet("QLabel { font-weight: bold; }")
bot_menu_layout.addRow("Search ApPhase ID:",
self._search_apPhase_combo)
bot_menu_layout.addRow("Search Address:", self._search_address_combo)
return bot_menu
def setTabs(self):
#self._tabs = QTabWidget(self)
self._tab_label = QLabel("Client", self)
self._tab_label.setObjectName("tablabel")
self._tab_label.setStyleSheet(
'QLabel[objectName^="tablabel"] {font-size: 12pt; font-weight: bold;}'
)
self._tabs = QStackedWidget(self)
table_names = []
for table in Tables:
table_name = table.value.getTabName()
table_names.append(table_name)
table.value.setTab(self, self._database)
table.value.setFormParent(self)
#self._tabs.addTab(table.value, table_name)
self._tabs.addWidget(table.value)
self._form_menu = FormMenu(item_names=table_names, parent=self)
self._form_menu.currentRowChanged.connect(self.selectMenuItemChange)
def selectMenuItemChange(self, index):
self._tabs.setCurrentIndex(index)
text = self._form_menu.currentItem().text()
self._tab_label.setText(text)
self._data_table_label.setText(text + " Table")
self.updateDataTable()
self.updateDatabaseTable()
def updateDataTable(self):
self._data_table.setRowCount(0)
self._data_table.setRowCount(1)
data = self._tabs.currentWidget()
fields = data.getFields()
values = data.getValues()
col_count = len(values)
self._data_table.setColumnCount(col_count)
for col, (field, value) in enumerate(zip(fields, values)):
header = QTableWidgetItem(field)
item = QTableWidgetItem(str(value))
self._data_table.setHorizontalHeaderItem(col, header)
self._data_table.setItem(0, col, item)
#self._data_table.resizeColumnsToContents()
self._data_table.verticalHeader().setStretchLastSection(True)
def readDataFromDatabase(self):
for table in Tables:
table.value.readDataIntoForm(
self._search_apPhase_combo.currentText())
def setApPhaseChangeCheck(self, change):
self._ap_phase_change = change
for table in Tables:
table.value._ap_phase_change = change
def setAddressChangeCheck(self, change):
self._address_change = change
for table in Tables:
table.value._address_change = change
def setNewForTables(self, new_val):
self._new = new_val
for table in Tables:
table.value._new = new_val
def apPhaseComboChange(self):
if not self._address_change:
self.setApPhaseChangeCheck(True)
self.clearForm()
self.readDataFromDatabase()
self._search_address_combo.setCurrentIndex(
self._search_apPhase_combo.currentIndex())
self.updateDataTable()
self.setNewForTables(False)
self.setApPhaseChangeCheck(False)
def addressComboChange(self):
if not self._ap_phase_change:
self.setAddressChangeCheck(True)
self.clearForm()
self._search_apPhase_combo.setCurrentIndex(
self._search_address_combo.currentIndex())
self.readDataFromDatabase()
self.updateDataTable()
self.setNewForTables(False)
self.setAddressChangeCheck(False)
def newSearchApCombo(self):
if not self._address_change and self._search_apPhase_combo.currentText(
) == "":
self._ap_phase_change = True
Tables.CLIENT.value._ap_phase_change = True
self._search_address_combo.setCurrentText("")
self._ap_phase_widget.setPlaceholderText("Enter new ApPhase ID...")
self._address_widget.setPlaceholderText("Enter new Address...")
Tables.CLIENT.value.clearValues()
self.setNewForTables(True)
Tables.CLIENT.value._ap_phase_change = False
self._ap_phase_change = False
def newSearchAdrCombo(self):
if not self._ap_phase_change and self._search_address_combo.currentText(
) == "":
self._address_change = True
self._search_apPhase_combo.setCurrentText("")
self._ap_phase_widget.setPlaceholderText("Enter new ApPhase ID...")
self._address_widget.setPlaceholderText("Enter new Address...")
self.setNewForTables(True)
Tables.CLIENT.value.clearValues()
self._address_change = False
def updateSearchCombos(self):
ap_phase_id = self._ap_phase_widget.text()
search_data = getAddresses(
self._database.getValuesFrom2Fields(Tables.CLIENT.name,
Client.ADDRESS.name,
Client.AP_PHASE_ID.name))
search_ap_phase_ids = [value[1] for value in search_data]
search_addresses = [value[0] for value in search_data]
self._search_apPhase_combo.clear()
self._search_address_combo.clear()
self._search_apPhase_combo.addItems(search_ap_phase_ids)
self._search_address_combo.addItems(search_addresses)
index = self._search_apPhase_combo.findText(ap_phase_id)
self._search_apPhase_combo.setCurrentIndex(index)
def updateDatabaseTable(self):
if self._main_tabs.currentIndex() == 1:
table_name = self._tabs.currentWidget().getTableName()
tab_name = self._tabs.currentWidget().getTabName()
self._database_table_label.setText("Table: {tn} ({tbn})".format(
tn=table_name, tbn=tab_name))
self._database.openDatabase()
data = self._database.readTable(table_name)
self._database.closeDatabase()
headers = getFieldNames(table_name)
data_count = len(data)
self._database_table.setRowCount(0)
self._database_table.setColumnCount(len(headers))
self._database_table.setRowCount(data_count)
for col, header_text in enumerate(headers):
header = QTableWidgetItem(header_text)
self._database_table.setHorizontalHeaderItem(col, header)
for row, data_row in enumerate(data):
data_row = list(data_row)
data_row.pop(0)
for col, data_value in enumerate(data_row):
item = QTableWidgetItem(str(data_value))
self._database_table.setItem(row, col, item)
def exportDatabaseTable(self):
file_name = self.exportCSVDialog()
temp_row = []
headers = []
for col in range(self._database_table.columnCount()):
headers.append(
self._database_table.horizontalHeaderItem(col).text())
if file_name:
with open(file_name, 'w', newline='') as n_f:
writer = csv.writer(n_f)
writer.writerow(headers)
for row in range(self._database_table.rowCount()):
for col in range(self._database_table.columnCount()):
temp_row.append(
self._database_table.item(row, col).text())
writer.writerow(temp_row)
temp_row.clear()
def exportCSVDialog(self):
file_dialog = QFileDialog()
file_name, ext = file_dialog.getSaveFileName(self, 'Export CSV File',
"", "CSV (*.csv)")
return file_name
def mainTabChange(self, index):
if index == 1:
self.updateDatabaseTable()
def start(self):
with open(self.main_style_qss, 'r') as main_qss:
main_style = main_qss.read()
app.setStyleSheet(main_style)
self.showMaximized()
sys.exit(app.exec_())
