class MainForm(QDialog):
def __init__(self, datalist, header, parent=None):
super(MainForm, self).__init__(parent)
self.setWindowTitle("Raio-X do Orçamento Helper")
self.setMinimumSize(800, 600)
self.year_label = QLabel("Ano")
self.year_input = QLineEdit("2019")
self.selection_button = QPushButton("Selecionar pasta")
self.selection_button.clicked.connect(self.select_folder)
self.update_button = QPushButton("Atualizar Dados")
self.update_button.clicked.connect(self.update)
self.folder_address_input = QLineEdit(".")
layout = QVBoxLayout()
# layout.addWidget(self.year_label)
layout.addWidget(self.year_input)
hlayout = QHBoxLayout()
hlayout.addWidget(self.selection_button)
hlayout.addWidget(self.folder_address_input)
layout.addLayout(hlayout)
# tabela
self.datalist = datalist
self.table_model = UnitTableModel(self, datalist, header)
self.table_view = QTableView()
#self.table_view.setSelectionMode(QAbstractItemView.SingleSelection)
# self.table_view.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table_view.setModel(self.table_model)
# bind cell click to a method reference
# self.table_view.clicked.connect(self.showSelection)
# self.table_view.clicked.connect(self.selectRow)
# enable sorting
# self.table_view.setSortingEnabled(True)
self.resize_header()
layout.addWidget(self.table_view)
layout.addWidget(self.update_button)
self.setLayout(layout)
def resize_header(self):
header = self.table_view.horizontalHeader()
header.setSectionResizeMode(0, QHeaderView.Stretch)
header.setSectionResizeMode(1, QHeaderView.Stretch)
header.setSectionResizeMode(2, QHeaderView.ResizeToContents)
def showSelection(self, item):
cellContent = item.data()
# print(cellContent) # test
sf = "You clicked on {}".format(cellContent)
# display in title bar for convenience
self.setWindowTitle(sf)
def update_model(self, folder):
filenames = os.listdir(folder)
self.datalist = [(unit, nearest(unit, filenames), QCheckBox())
for unit in data.units]
self.table_model = UnitTableModel(self, self.datalist, HEADER)
self.table_view.setModel(self.table_model)
self.table_view.update()
def select_folder(self):
dialog = QFileDialog(self)
dialog.setFileMode(QFileDialog.Directory)
if dialog.exec_():
selected_dir = dialog.selectedFiles()[0]
self.folder_address_input.setText(selected_dir)
self.update_model(selected_dir)
def compress_files(self):
files_dir = self.folder_address_input.text()
for row in self.datalist:
print("Compressing file {}".format(row[1]))
compressfile(os.path.join(files_dir, row[1]),
os.path.join(files_dir, row[0]))
def upload_files(self):
files_dir = self.folder_address_input.text()
for count, row in enumerate(self.datalist):
print("Uploading file {}".format(row[0]))
# TODO: read year from UI (combobox?)
upload_sheet(os.path.join(files_dir, row[0]), 2019)
self.table_model.update_row_status(count, Status.SENT)
print("Files uploaded")
def update(self):
print("Updating files")
self.compress_files()
self.upload_files()
print("Update completed")
class TreeCard(QDialog):
def __init__(self, db=0, mode=0):
super().__init__()
layout = QGridLayout()
#self.central_widget.setLayout(layout)
self.resize(800, self.height())
self.lb_find = QInvisibleButton('Поиск')
self.lb_find.setFont(mainfont)
self.te_find = QLineEdit()
self.te_find.setFont(mainfont)
self.pid = 0
layout.addWidget(self.te_find, 0, 0, 1, 1)
layout.addWidget(self.lb_find, 0, 0, 1, 1)
#if mode:
# te.setReadOnly(False)
self.lb_find.clicked.connect(self.button_pressed)
self.te_find.returnPressed.connect(self.line_edit_return_pressed)
self.database = db
self.table = QTableView() # Создаём таблицу
self.table.doubleClicked.connect(self.viewPerson)
#self.table = table
self.model = TableModel(self.database.get_peoples())
self.table.setModel(self.model)
self.table.resizeRowsToContents()
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
#self.table.setSelectionMode(QAbstractItemView.SingleSelection);
self.model.dataChanged.connect(self.table.update)
layout.addWidget(self.table)
self.setLayout(layout)
def viewPerson(self):
select = self.table.selectionModel()
pid_list = [
index.data()
for index in self.table.selectionModel().selection().indexes()
if index.column() == 0
]
if len(pid_list) == 1:
self.pid = int(pid_list[0])
print(int(pid_list[0]))
self.accept()
return 0
def button_pressed(self):
#sender = self.sender()
self.lb_find.stackUnder(self.te_find)
self.te_find.setFocus()
def line_edit_return_pressed(self):
print(self.te_find.text())
self.model = TableModel(self.database.get_peoples())
self.proxy_model = QSortFilterProxyModel(self.model)
self.proxy_model.setSourceModel(self.model)
self.proxy_model.setFilterFixedString(self.te_find.text())
self.proxy_model.setFilterKeyColumn(-1)
#print(self.proxy_model.filterKeyColumn())
self.table.setModel(self.proxy_model)
self.table.update()
self.table.resizeRowsToContents()
#sender = self.sender()
self.te_find.stackUnder(self.lb_find)
self.lb_find.setFocus()
class TdisMainForm(QMainWindow):
def __init__(self, parent=None):
super().__init__()
self.setWindowTitle("Родословная")
self.resize(800, self.height())
self.distance = 1000
self.central_widget = QWidget()
self.setCentralWidget(self.central_widget)
layout = QGridLayout()
self.central_widget.setLayout(layout)
self.lb_find = QInvisibleButton('Поиск')
self.lb_find.setFont(mainfont)
self.te_find = QLineEdit()
self.te_find.setFont(mainfont)
layout.addWidget(self.te_find, 0, 0, 1, 1)
layout.addWidget(self.lb_find, 0, 0, 1, 1)
#if mode:
# te.setReadOnly(False)
self.lb_find.clicked.connect(self.button_pressed)
self.te_find.returnPressed.connect(self.line_edit_return_pressed)
self.table = QTableView() # Создаём таблицу
self.table.doubleClicked.connect(self.viewPerson)
layout.addWidget(self.table)
self.table.setFocus()
timer = QTimer(self)
timer.singleShot(0, self.async_init)
def async_init(self):
self.database = AllTables('database/objects')
self.model = TableModel(self.database.get_peoples())
self.table.setModel(self.model)
self.table.resizeRowsToContents()
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.model.dataChanged.connect(self.table.update)
# Работаем с выпадающим меню
def openMenu(position):
menu = QMenu()
relAction = menu.addAction('Связи')
menu.addSeparator()
albAction = menu.addAction('Альбомы')
menu.addSeparator()
miniatureAction = menu.addAction('Миниатюра')
menu.addSeparator()
viewAction = menu.addAction('Просмотреть')
addAction = menu.addAction('Добавить')
editAction = menu.addAction('Редактировать')
delAction = menu.addAction('Удалить')
menu.addSeparator()
drawGraphAction = menu.addAction('Построить дерево')
menu.addSeparator()
quitAction = menu.addAction('Выход')
action = menu.exec_(self.table.mapToGlobal(position))
if action == viewAction:
self.viewPerson()
if action == miniatureAction:
p = self.get_selected_people()
print('p = ' + str(p))
if p is not None:
photo_ids = self.database.get_all_photo_ids(p['pid'])
path = 0
if photo_ids and type(photo_ids) == type(
[]) and len(photo_ids) > 0:
path = self.database.get_photo_path(
p['pid'], photo_ids[0])
gm = GalleryMiniature(p['pid'], path)
gm.exec()
if action == albAction:
p = self.get_selected_people()
if p is not None:
self.albuns = AlbumViewer(p['pid'], self.database, 1)
self.albuns.show()
if action == addAction:
self.personal_card = PersonalCard(
self.database.get_people(self.database.add_people({})),
self.database, 1)
self.personal_card.exec_()
self.line_edit_return_pressed()
if action == editAction:
p = self.get_selected_people()
if p is not None:
self.personal_card = PersonalCard(p, self.database, 1)
self.personal_card.exec_()
self.line_edit_return_pressed()
if action == delAction:
res = QMessageBox.question(
self, 'ВНИМАНИЕ!!!',
"Вы действительно хотите выполнить удаление?",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if res == QMessageBox.Yes:
select = self.table.selectionModel()
if select.hasSelection():
id_list = [
index.data() for index in
self.table.selectionModel().selection().indexes()
if index.column() == 0
]
print(id_list)
self.database.del_people(id_list)
self.database.peoples.save()
for pid in id_list:
print('remove = ' + str(self.model.removeRow(pid)))
self.line_edit_return_pressed()
if action == relAction:
pid = self.get_selected_pid()
backup_relations = copy.deepcopy(self.database.relations)
self.relation_card = RelationCard(pid, self.database, 2)
if not self.relation_card.exec_():
self.database.relations = backup_relations
if action == drawGraphAction:
print('draw graph')
#dialog = MyDialog()
#dialog.exec_()
#engine = dialog.engine
engine = 'dot'
self.gd = GraphDrawer(self.database, engine)
if action == quitAction:
qApp.quit()
self.table.setContextMenuPolicy(Qt.CustomContextMenu)
self.table.customContextMenuRequested.connect(openMenu)
def get_selected_pid(self):
pid_list = [
index.data()
for index in self.table.selectionModel().selection().indexes()
if index.column() == 0
]
if len(pid_list) == 1:
return int(pid_list[0])
return None
def get_selected_people(self):
pid_list = [
index.data()
for index in self.table.selectionModel().selection().indexes()
if index.column() == 0
]
if len(pid_list) == 1:
return self.database.get_people(int(pid_list[0]))
return None
def viewPerson(self):
p = self.get_selected_people()
if p is not None:
self.personal_card = PersonalCard(p, self.database, 0)
self.personal_card.show()
def button_pressed(self):
self.lb_find.stackUnder(self.te_find)
self.te_find.setFocus()
def line_edit_return_pressed(self):
print(self.te_find.text())
self.model = TableModel(self.database.get_peoples())
self.proxy_model = QSortFilterProxyModel(self.model)
self.proxy_model.setSourceModel(self.model)
self.proxy_model.setFilterFixedString(self.te_find.text())
self.proxy_model.setFilterKeyColumn(-1)
self.table.setModel(self.proxy_model)
self.table.update()
self.table.resizeRowsToContents()
#sender = self.sender()
self.te_find.stackUnder(self.lb_find)
self.lb_find.setFocus()
class DLPSettingsGUI(QWidget):
def __init__(self, dlp_controller=None, dlp_slicer=None, parent=None):
QWidget.__init__(self, parent)
self.parent = parent
self.dlp_controller = dlp_controller
self.dlp_slicer = dlp_slicer
self.dlp_color_calibrator = DLPColorCalibrator()
self.dlp_color_calibrator.analysis_completed_signal.connect(self.update_charts)
self.__printer_parameters_list = {}
self.__slicer_parameters_list = {}
self.data_fit_chart_view = None
self.data_fit_chart = None
self.main_layout = QHBoxLayout()
self.__init_table_widget__()
self.__init_color_calibration_widget()
self.__default_parameters_widget.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.MinimumExpanding)
self.main_layout.addWidget(self.__default_parameters_widget, stretch=1)
self.main_layout.addWidget(self.__color_calibration_widget, stretch=2)
self.setLayout(self.main_layout)
self.main_layout.update()
def __init_color_calibration_widget(self, parent=None):
self.__color_calibration_widget = QGroupBox("Color Correction Options", parent)
self.__color_calibration_widget.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
color_calibration_layout = QVBoxLayout(self.__color_calibration_widget)
chart_widget = QWidget(self.__color_calibration_widget)
chart_layout = QGridLayout(chart_widget)
self.data_fit_chart = QtCharts.QChart()
self.data_fit_chart_view = QtCharts.QChartView(self.data_fit_chart)
self.axis_x = QtCharts.QValueAxis()
self.axis_x.setTitleText("Pixel Intensity")
self.axis_x.setRange(0, 1)
self.data_fit_chart.addAxis(self.axis_x, Qt.AlignBottom)
self.axis_y = QtCharts.QValueAxis()
self.axis_y.setTitleText("Voxel Height (\u03BCm)")
self.axis_y.setRange(0, 10)
self.data_fit_chart.addAxis(self.axis_y, Qt.AlignLeft)
chart_layout.addWidget(self.data_fit_chart_view, 0, 0, 1, 4)
chart_widget.setLayout(chart_layout)
buttons_widget = QWidget(self.__color_calibration_widget)
buttons_layout = QHBoxLayout(buttons_widget)
analyze_data_button = QPushButton("Analyze Data")
analyze_data_button.clicked.connect(self.analyze_images)
self.parameters_estimation_label = QLabel(f'Estimated parameters: \u03B1 = {self.dlp_color_calibrator.optimized_parameters[0]:.3f}, \u03B2 = {self.dlp_color_calibrator.optimized_parameters[1]:.3f}, \u03B3 = {self.dlp_color_calibrator.optimized_parameters[2]:.3f}',
buttons_widget)
buttons_layout.addWidget(analyze_data_button)
buttons_layout.addWidget(self.parameters_estimation_label)
buttons_widget.setLayout(buttons_layout)
color_calibration_layout.addWidget(chart_widget)
color_calibration_layout.addWidget(buttons_widget)
self.__color_calibration_widget.setLayout(color_calibration_layout)
@Slot()
def analyze_images(self):
file_names = QFileDialog.getOpenFileNames(caption='Select data', dir='../measured_data/grayscale_measured_data',
filter="Image Files (*.asc)")
self.dlp_color_calibrator.analyze_data_files(file_names[0])
@Slot()
def update_charts(self):
self.data_fit_chart = QtCharts.QChart()
self.data_fit_chart.setAnimationOptions(QtCharts.QChart.AllAnimations)
self.add_series(self.data_fit_chart, "Measured Data", self.dlp_color_calibrator.input_values, self.dlp_color_calibrator.average_data)
self.add_series(self.data_fit_chart, "Fitted Curve", self.dlp_color_calibrator.input_values,
self.dlp_color_calibrator.fitted_curve)
self.add_series(self.data_fit_chart, "Predicted Result", self.dlp_color_calibrator.input_values,
self.dlp_color_calibrator.corrected_output_values)
series = self.data_fit_chart.series()
self.data_fit_chart.addAxis(self.axis_x, Qt.AlignBottom)
self.axis_y.setRange(0, self.dlp_color_calibrator.measured_thickness)
self.data_fit_chart.addAxis(self.axis_y, Qt.AlignLeft)
for s in series:
s.attachAxis(self.axis_x)
s.attachAxis(self.axis_y)
self.data_fit_chart_view.setRenderHint(QPainter.Antialiasing)
self.data_fit_chart_view.setChart(self.data_fit_chart)
self.parameters_estimation_label.setText(f'Estimated parameters: \u03B1 = {self.dlp_color_calibrator.optimized_parameters[0]:.3f}, \u03B2 = {self.dlp_color_calibrator.optimized_parameters[1]:.3f}, \u03B3 = {self.dlp_color_calibrator.optimized_parameters[2]:.3f}')
def add_series(self, chart, title, x, y):
series = QtCharts.QLineSeries()
series.setName(title)
for idx, elem in enumerate(x):
series.append(x[idx], y[idx])
chart.addSeries(series)
def __init_table_widget__(self, parent=None):
self.__default_parameters_widget = QGroupBox("Default Parameters", parent)
self.printer_parameters_list = self.dlp_controller.get_default_parameters()
self.table_view = QTableView()
self.table_model = self.MyTableModel(parent=self.__default_parameters_widget, data_list=self.printer_parameters_list)
self.table_view.setModel(self.table_model)
self.table_view.horizontalHeader().setVisible(False)
self.table_view.verticalHeader().setVisible(False)
self.table_view.horizontalHeader().setStretchLastSection(False)
# self.table_view.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.table_view.resizeColumnsToContents()
self.table_view.update()
# self.table_view.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
# self.table_view.setSizeAdjustPolicy(QAbstractScrollArea.AdjustToContents)
apply_button = QPushButton("Apply Changes", self.__default_parameters_widget)
apply_button.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
apply_button.clicked.connect(self.dlp_controller.save_default_parameters)
default_parameters_layout = QVBoxLayout(self.__default_parameters_widget)
default_parameters_layout.addWidget(self.table_view)
default_parameters_layout.addWidget(apply_button)
self.__default_parameters_widget.setLayout(default_parameters_layout)
self.__default_parameters_widget.updateGeometry()
# default_parameters_layout.update()
# QGuiApplication.processEvents()
@Slot()
def __adjust_table_size__(self):
self.table_view.resizeColumnToContents(0)
self.table_view.resizeColumnToContents(1)
rect = self.table_view.geometry()
rect.setWidth(1 + self.table_view.verticalHeader().width() + self.table_view.columnWidth(0) +
self.table_view.columnWidth(1) + self.table_view.verticalScrollBar().width())
self.table_view.setGeometry(rect)
self.table_view.resize(rect.width(), rect.height())
class MyTableModel(QAbstractTableModel):
def __init__(self, parent, data_list, *args):
QAbstractTableModel.__init__(self, parent, *args)
self.parent = parent
self.data_list = data_list
def rowCount(self, parent):
return len(self.data_list)
def columnCount(self, parent):
return 2
def data(self, index, role):
if not index.isValid():
return None
elif role != Qt.DisplayRole:
return None
return list(self.data_list.items())[index.row()][index.column()]
def setData(self, index, value, role):
if role == Qt.EditRole:
if not index.isValid():
return False
elif index.column() == 0:
return False
else:
key = list(self.data_list.items())[index.row()][0]
old_value = list(self.data_list.items())[index.row()][1]
try:
if isinstance(old_value, float):
self.data_list[key] = float(value)
elif isinstance(old_value, bool):
if value == "True" or value == "true":
self.data_list[key] = True
else:
self.data_list[key] = False
elif isinstance(old_value, str):
if index.row() == 0:
if not (value.upper() == "TOP-DOWN" or value.upper() == "BOTTOM-UP"):
return False
self.data_list[key] = str(value).upper()
except ValueError:
return False
self.dataChanged.emit(index, index)
return True
else:
return False
def flags(self, index):
if not index.isValid() or index.column() == 0:
return Qt.ItemIsEnabled
return Qt.ItemFlags(QAbstractTableModel.flags(self, index) |
Qt.ItemIsEditable)
class MainWin(QWidget):
def __init__(self):
super().__init__()
self.dbConnector = cPl.DBConnector("timePlanner.db", "Task",
ormMapping)
self.taskStorage = cPl.TaskStorage(self.dbConnector, ormMapping)
self.currentView = "Work"
self.checkBox = QCheckBox('Minimize to Tray')
self.checkBox.setChecked(True)
self.createModels()
self.grid = QGridLayout()
self.tray_icon = QSystemTrayIcon()
self.tray_icon.setToolTip("Time Planner")
self.tray_icon.setIcon(self.style().standardIcon(
QStyle.SP_ComputerIcon))
traySignal = "activated(QSystemTrayIcon::ActivationReason)"
QObject.connect(self.tray_icon, SIGNAL(traySignal),
self.__icon_activated)
#appendFunc = anonFuncString("Total time")
appendDataFinished = [
cPl.AppendDataView(self.finishedModel, 3,
self.taskStorage.getTotalWorkTime,
workTimeFormat),
cPl.AppendDataView(self.finishedModel, 2, anonFuncString)
]
self.finishedModel.setAppendData(appendDataFinished)
self.initUI()
def hideEvent(self, event):
if self.checkBox.isChecked():
event.ignore()
self.hide()
self.tray_icon.show()
def __icon_activated(self, reason):
if reason == QSystemTrayIcon.Trigger:
self.show()
def __resizeView(self):
self.view.horizontalHeader().setSectionResizeMode(
0, QHeaderView.Stretch)
if self.currentView == "Work":
self.view.horizontalHeader().setSectionResizeMode(
1, QHeaderView.Fixed)
self.view.horizontalHeader().setSectionResizeMode(
2, QHeaderView.Fixed)
self.view.horizontalHeader().setSectionResizeMode(
3, QHeaderView.ResizeToContents)
self.view.setColumnWidth(1, 140)
self.view.setColumnWidth(2, 70)
self.view.setColumnWidth(self.model.getHeaderLenght(), 70)
self.view.setColumnWidth(self.model.getHeaderLenght() + 1, 70)
self.view.setColumnWidth(self.model.getHeaderLenght() + 2, 70)
self.view.setColumnWidth(self.model.getHeaderLenght() + 3, 70)
else:
self.view.horizontalHeader().setSectionResizeMode(
1, QHeaderView.Fixed)
self.view.horizontalHeader().setSectionResizeMode(
2, QHeaderView.Fixed)
self.view.horizontalHeader().setSectionResizeMode(
3, QHeaderView.ResizeToContents)
self.view.setColumnWidth(1, 140)
self.view.setColumnWidth(2, 140)
def initUI(self):
self.taskStorage.Model = self.model
grid = self.grid
self.setLayout(grid)
buttonCurrent = QPushButton('Current Task')
buttonCurrent.setCheckable(True)
buttonFinished = QPushButton('Finished Task')
buttonFinished.setCheckable(True)
buttonCurrent.setMaximumWidth(100)
buttonFinished.setMaximumWidth(100)
self.move(300, 150)
self.setMinimumWidth(1100)
self.setMinimumHeight(400)
self.setWindowTitle('Time Planner')
top_Panel = self.createTop()
grid.addWidget(top_Panel, 0, 0)
self.view = QTableView()
self.view.setModel(self.model)
stylesheet = "QHeaderView::section{color: grey; border: 2px solid #6c6c6c; border-width: 0px 0px 2px 0px; " \
"border-style: dotted; border-color: black} "
self.view.setStyleSheet(stylesheet)
self.__resizeView()
#Create here else garbage collector clear it
self.buttonStart = cPl.StartButtonDelegate(self.taskStorage, "taskId")
self.buttonPause = cPl.PauseButtonDelegate(self.taskStorage, "taskId")
self.buttonFinish = cPl.FinishButtonDelegate(self.taskStorage,
"taskId")
self.buttonDelete = cPl.DeleteButtonDelegate(self.taskStorage,
"taskId", self)
if self.currentView == "Work":
self.view.setItemDelegateForColumn(self.model.getHeaderLenght(),
self.buttonStart)
self.view.setItemDelegateForColumn(
self.model.getHeaderLenght() + 1, self.buttonPause)
self.view.setItemDelegateForColumn(
self.model.getHeaderLenght() + 2, self.buttonFinish)
self.view.setItemDelegateForColumn(
self.model.getHeaderLenght() + 3, self.buttonDelete)
buttonCurrent.setChecked(True)
buttonFinished.setChecked(False)
else:
self.view.setItemDelegateForColumn(self.model.getHeaderLenght(),
self.buttonDelete)
buttonCurrent.setChecked(False)
buttonFinished.setChecked(True)
viewPanel = self.createTaskView(self.view)
grid.addWidget(viewPanel, 1, 0)
buttonPanel = self.createButtonView()
grid.addWidget(buttonPanel, 1, 1)
grid.addWidget(self.checkBox, 2, 0)
self.show()
# Top panel - LineEdit for task name + Add new task button
def createTop(self):
topPanel = QWidget()
topPanel.setContentsMargins(0, 0, 0, 0)
hBox = QHBoxLayout()
vBox = QVBoxLayout()
lineEdit = QLineEdit('')
lineEdit.setPlaceholderText("Enter new task name")
buttonAdd = QPushButton('Add Task')
buttonAdd.clicked.connect(self.add_newTask(lineEdit))
hBox.addWidget(lineEdit)
lineEdit.setMinimumWidth(250)
hBox.addWidget(buttonAdd)
hBox.addStretch(1)
vBox.addLayout(hBox)
topPanel.setLayout(vBox)
return topPanel
def createTaskView(self, view):
hBox = QHBoxLayout()
viewPanel = QWidget()
hBox.addWidget(view)
viewPanel.setLayout(hBox)
return viewPanel
def createButtonView(self):
buttons = []
datePickers = []
buttonPanel = QWidget()
buttonPanel.setContentsMargins(0, 0, 0, 0)
buttonCurrent = QPushButton('Current tasks')
buttonCurrent.setCheckable(True)
buttonFinished = QPushButton('Finished tasks')
buttonFinished.setCheckable(True)
buttonFilter = QPushButton("Filter by end date")
buttonApply = QPushButton("Apply")
buttonFilter.setCheckable(True)
buttonCurrent.setMaximumWidth(100)
buttonFinished.setMaximumWidth(100)
buttonFilter.setMaximumWidth(100)
buttonApply.setMaximumWidth(100)
buttonCurrent.setMinimumWidth(100)
buttonFinished.setMinimumWidth(100)
buttonFilter.setMinimumWidth(100)
buttonApply.setMinimumWidth(100)
buttons.append(buttonFilter)
#
labelStart = QLabel("Date start")
datePickers.append(labelStart)
dateStart = QDateEdit()
dateStart.setDisplayFormat('dd/MM/yyyy')
dateStart.setCalendarPopup(True)
dateStart.setDate(QDate.currentDate())
datePickers.append(dateStart)
labelEnd = QLabel("Date end")
datePickers.append(labelEnd)
dateEnd = QDateEdit()
dateEnd.setDisplayFormat('dd/MM/yyyy')
dateEnd.setCalendarPopup(True)
dateEnd.setDate(QDate.currentDate())
datePickers.append(dateEnd)
datePickers.append(buttonApply)
buttonCurrent.clicked.connect(
self.switchCurrentTask(buttonFinished, buttonCurrent, buttons))
buttonFinished.clicked.connect(
self.switchFinishedTask(buttonCurrent, buttonFinished, buttons))
buttonFilter.clicked.connect(
self.openDatePickerFilter(datePickers, buttonFilter))
buttonApply.clicked.connect(
self.ApplyDateFilterArchive(dateStart, dateEnd))
buttonCurrent.setChecked(True)
vBox = QVBoxLayout()
vBox.addWidget(buttonCurrent)
vBox.addWidget(buttonFinished)
vBox.addSpacing(30)
for bnt in buttons:
bnt.setVisible(False)
vBox.addWidget(bnt)
for datePicker in datePickers:
datePicker.setVisible(False)
vBox.addWidget(datePicker)
vBox.addStretch(1)
buttonPanel.setLayout(vBox)
return buttonPanel
def add_newTask(self, lineEdit):
def call_sql():
if lineEdit.text() != "":
self.taskStorage.addTask(lineEdit.text())
self.model.refresh()
return call_sql
def openDatePickerFilter(self, filterElements, clickBtn):
def call():
if not clickBtn.isChecked():
for filterElement in filterElements:
filterElement.setVisible(False)
self.taskStorage.viewAllFinishedTask()
self.finishedModel.refresh()
else:
for filterElement in filterElements:
filterElement.setVisible(True)
return call
def ApplyDateFilterArchive(self, dateStart, dateEnd):
def call():
start = datetime.combine(dateStart.date().toPython(),
datetime.min.time())
end = datetime.combine(dateEnd.date().toPython(),
datetime.min.time())
startUTC = int(float(start.timestamp()))
endUTC = int(float(end.timestamp()))
self.finishedModel.switchToFilterData(startUTC, endUTC)
self.finishedModel.refresh()
return call
def switchCurrentTask(self, buttonInAct, btnAct, btnsFilter):
def call():
if self.currentView != "Work":
self.model.setAllTaskView()
self.view.setModel(self.model)
self.view.setItemDelegateForColumn(
self.model.getHeaderLenght(), self.buttonStart)
self.view.setItemDelegateForColumn(
self.model.getHeaderLenght() + 1, self.buttonPause)
self.view.setItemDelegateForColumn(
self.model.getHeaderLenght() + 2, self.buttonFinish)
btnAct.setChecked(True)
buttonInAct.setChecked(False)
for btn in btnsFilter:
btn.setVisible(False)
self.currentView = "Work"
self.__resizeView()
return call
def switchFinishedTask(self, buttonInAct, btnAct, btnsFilter):
def call():
if self.currentView != "Archive":
self.finishedModel.switchToAllDataView()
self.view.setModel(self.finishedModel)
self.view.setItemDelegateForColumn(
self.model.getHeaderLenght(), self.buttonDelete)
btnAct.setChecked(True)
buttonInAct.setChecked(False)
for btn in btnsFilter:
btn.setVisible(True)
self.currentView = "Archive"
self.__resizeView()
return call
def createModels(self):
self.model = cPl.TaskModel(self.taskStorage, ormMapping, 0, buttonData,
self) # передаем хранилище задач в модель
self.finishedModel = cPl.TaskModel(self.taskStorage,
ormMappingFinished, 1,
buttonDataFinish, self)
def updateView(self):
self.view.update()
