class Dialog(QDialog):
def __init__(self,
title=None,
minsize=QSize(640, 480),
maxsize=QSize(1200, 1200)):
QDialog.__init__(self)
self.db = Database()
self.setWindowTitle(title)
self.setMinimumSize(minsize)
self.setMaximumSize(maxsize)
self.init_layout()
accepted = self.exec_()
if accepted == QDialog.Accepted:
values = Form.get_all_values()
self.db.insert_row_to_table(values)
def init_layout(self):
layout = Form.make_form(self.accept, self.reject)
self.setLayout(layout)
def __init__(self, values, _column, c, foreign_keys, pk_id):
QComboBox.__init__(self)
self.db = Database()
self.pk_id = pk_id
self.column = _column
self.init(values, _column, c, foreign_keys)
def __init__(self, name, foreign_keys):
QTableWidget.__init__(self)
self.name = name
self.foreign_keys = foreign_keys
self.db = Database()
self.setMinimumSize(640, 480)
self.resize(900, 900)
class Tabs(QTabWidget):
def __init__(self):
QTabWidget.__init__(self)
self.db = Database()
def make_tabs(self):
tabs = []
for table in self.db.get_all_tables():
data = self.db.get_table_data(table, 0)
_tab = {
'title': table,
'content': data,
}
tabs.append(_tab)
Store.add_tab({
'title': table,
'last_row_loaded': Database.ROWS_PER_LOAD,
})
self.init_tabs()
self.add_tabs(tabs)
def init_tabs(self):
self.resize(900, 900)
self.setMinimumSize(640, 480)
self.currentChanged.connect(self.tab_click)
def add_tabs(self, tabs):
for i, _tab in enumerate(tabs):
name = _tab['title']
table_foreign_keys = self.db.get_foreign_keys(name)
Store.add_foreign_keys(i, table_foreign_keys)
_table = Table(name, table_foreign_keys)
table = _table.generate_table(
list(map(lambda t: str(t), _tab['content']['headers'])),
_tab['content']['rows'])
Store.add_table(i, _table)
self.addTab(_table, name)
@pyqtSlot()
def tab_click(self):
current_tab = self.currentIndex()
Store.set_current_tab(current_tab)
class Form():
db = Database()
form_layout = None
@staticmethod
def make_form(accept, reject):
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
buttonBox.accepted.connect(accept)
buttonBox.rejected.connect(reject)
fomr_group_box = Form.create_form_froup_box()
layout = QVBoxLayout()
layout.addWidget(fomr_group_box)
layout.addWidget(buttonBox)
return layout
@staticmethod
def create_form_froup_box():
form_group_box = QGroupBox("Insert a new row")
layout = QFormLayout()
current_table = Store.get_current_tab()['title']
Form.make_custom_fields(layout, current_table)
form_group_box.setLayout(layout)
Form.form_layout = form_group_box
return form_group_box
@staticmethod
def make_combobox(items):
cb = QComboBox()
for item in items:
cb.addItem(item)
return cb
@staticmethod
def make_custom_fields(layout, table_name):
fields = Form.db.get_table_columns_names(table_name)
for field in fields:
layout.addRow(QLabel(field), QLineEdit())
@staticmethod
def get_all_values():
return [
field.text() for field in Form.form_layout.findChildren(QLineEdit)
]
class ComboBox(QComboBox):
def __init__(self, values, _column, c, foreign_keys, pk_id):
QComboBox.__init__(self)
self.db = Database()
self.pk_id = pk_id
self.column = _column
self.init(values, _column, c, foreign_keys)
def init(self, values, _column, c, foreign_keys):
headers = values['headers']
foreign_key_position = headers.index(foreign_keys[_column]['column'])
is_found_value = False
for val_index, v in enumerate(values['rows']):
val = " | ".join([str(_v) for _v_index, _v in enumerate(v) if _v_index != foreign_key_position])
val = (val[:35] + '..') if len(val) > 35 else val
foreign_key_value = v[foreign_key_position]
self.addItem(val, foreign_key_value)
if v[foreign_key_position] == c:
self.setCurrentIndex(val_index)
is_found_value = True
self.insertItem(0, 'NULL', 'NULL')
if not is_found_value:
self.setCurrentIndex(0)
self.currentIndexChanged.connect(self.combobox_changed)
def combobox_changed(self, item):
table = Store.get_current_tab()
new_val = self.currentData()
self.db.update_table_column(table, self.pk_id, self.column, new_val)
class Table(QTableWidget):
PERCENT_TO_START_LOADING = 0.9
def __init__(self, name, foreign_keys):
QTableWidget.__init__(self)
self.name = name
self.foreign_keys = foreign_keys
self.db = Database()
self.setMinimumSize(640, 480)
self.resize(900, 900)
def init_signals(self):
self.cellChanged.connect(self.cell_cnanged)
def get_value_in_cell(self, row, col):
item = self.item(row, col)
return item.text()
def cell_cnanged(self, row, col):
table = Store.get_current_tab()
pk_id = self.get_value_in_cell(row, 0)
value = self.get_value_in_cell(row, col)
col_name = self.get_col_name(col)
self.db.update_table_column(table, pk_id, col_name, value)
def get_col_name(self, col):
item = self.horizontalHeaderItem(col)
return item.text()
def wheelEvent(self, evt):
super().wheelEvent(evt)
scrollbar = self.verticalScrollBar()
current = scrollbar.value()
maximum = scrollbar.maximum()
if current > maximum * self.PERCENT_TO_START_LOADING:
self.add_rows_to_table()
def generate_table(self, headers, rows):
self.init_table(headers, rows)
self.set_table_headers(headers)
self.set_table_rows(rows)
self.init_signals()
return self
def init_table(self, headers, rows):
self.setColumnCount(len(headers))
self.setRowCount(len(rows))
self.setHorizontalHeaderLabels(headers)
self.resizeColumnsToContents()
self.resizeRowsToContents() # this line doesn't work actually, next one span cells to theirs content
self.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
return self
def set_table_headers(self, headers):
for i, h in enumerate(headers):
self.horizontalHeaderItem(i).setToolTip(h)
self.horizontalHeaderItem(i).setTextAlignment(Qt.AlignLeft)
def set_table_rows(self, rows):
for i, r in enumerate(rows):
self.set_row_columns(r, i)
def set_row_columns(self, row, rowPosition):
for j, c in enumerate(row):
item = QTableWidgetItem(str(c))
if j == 0:
item.setFlags( Qt.ItemIsSelectable | Qt.ItemIsEnabled )
self.setItem(rowPosition, j, item)
if self.is_column_foreign_key(j):
_column = self.get_col_name(j)
values = self.get_foreign_key_values(_column)
pk_id = self.get_value_in_cell(rowPosition, 0)
comboBox = ComboBox(values, _column, c, self.foreign_keys, pk_id)
self.setCellWidget(rowPosition, j, comboBox)
def get_foreign_key_values(self, column):
table = self.foreign_keys[column]['table']
column = self.foreign_keys[column]['column']
res = self.db.get_table_data_by_foreign_key(table)
return res
def is_column_foreign_key(self, column):
if len(self.foreign_keys) > 0:
return self.get_col_name(column) in self.foreign_keys.keys()
return False
def add_row_to_table(self, row):
rowPosition = self.rowCount()
self.insertRow(rowPosition)
self.set_row_columns(row, rowPosition)
def add_rows_to_table(self):
rows = self.get_data_to_add()
for r in rows:
self.add_row_to_table(r)
def get_data_to_add(self):
current_tab = Store.get_current_tab()
last_row = current_tab['last_row_loaded']
last_row_loaded = last_row + Database.ROWS_PER_LOAD
data = self.db.get_table_data(current_tab['title'], last_row)
Store.set_last_row(Store.get_current_tab(), last_row_loaded)
return data['rows']
def contextMenuEvent(self, event):
menu = QMenu(self)
edit_action = QAction('Edit cell', self)
edit_action.triggered.connect(self.edit_cell)
menu.addAction(edit_action)
remove_action = QAction('Remove row', self)
remove_action.triggered.connect(self.remove_row)
menu.addAction(remove_action)
menu.popup(QCursor.pos())
def edit_cell(self):
cell = self.currentItem()
self.editItem(cell)
def remove_row(self):
row = self.currentRow()
table = Store.get_current_tab()
pk_id = self.get_value_in_cell(row, 0)
self.db.remove_table_row(table, pk_id)
for tab in Store.get_all_tabs():
if 'foreign_keys' in tab.keys():
for key in tab['foreign_keys']:
_info = tab['foreign_keys'][key]
if _info['table'] == self.name:
_connected_table_name = tab['title']
self.db.update_table_column(tab, 'NULL', key, pk_id, key)
self.removeRow(row)
def __init__(self):
QTabWidget.__init__(self)
self.db = Database()