class SystemTrayIcon(QObject):
clicked = pyqtSignal()
double_clicked = pyqtSignal()
def __init__(self, parent, menu, is_logging=False):
QObject.__init__(self)
def getIcon(name):
return QIcon(':/images/tray_icons/' + name + '.png')
self._icons = {
STATUS_INIT: getIcon("disconnected") if is_logging \
else getIcon("sync"),
STATUS_DISCONNECTED: getIcon("disconnected"),
STATUS_WAIT: getIcon("default"),
STATUS_PAUSE: getIcon("pause"),
STATUS_IN_WORK: getIcon("sync"),
STATUS_INDEXING: getIcon("sync"),
}
self._statuses = {
STATUS_INIT: tr("Pvtbox"),
STATUS_DISCONNECTED: tr("Pvtbox connecting..."),
STATUS_WAIT: tr("Pvtbox"),
STATUS_PAUSE: tr("Pvtbox paused"),
STATUS_IN_WORK: tr("Pvtbox syncing..."),
STATUS_INDEXING: tr("Pvtbox indexing...")
}
self._tray = QSystemTrayIcon(self._icons[STATUS_INIT], parent)
self.set_tool_tip(self._statuses[STATUS_INIT])
self._tray.setContextMenu(menu)
menu.aboutToShow.connect(self.clicked.emit)
self._tray.activated.connect(self._on_activated)
self._tray.installEventFilter(self)
self._tray.setVisible(True)
self._tray.show()
self._tray_show_timer = QTimer(self)
self._tray_show_timer.setInterval(3000)
self._tray_show_timer.setSingleShot(False)
self._tray_show_timer.timeout.connect(self.show)
def eventFilter(self, obj, ev):
if ev.type() == QEvent.ToolTip:
self.clicked.emit()
return False
def _on_activated(self, reason):
'''
Slot for system tray icon activated signal.
See http://doc.qt.io/qt-5/qsystemtrayicon.html
@param reason Tray activation reason
'''
if reason == QSystemTrayIcon.Trigger:
# This is usually when left mouse button clicked on tray icon
self.clicked.emit()
elif reason == QSystemTrayIcon.DoubleClick:
self.double_clicked.emit()
@property
def menu(self):
return self._tray.contextMenu()
def set_tool_tip(self, tip):
self._tray.setToolTip(tip)
def show_tray_notification(self, text, title=""):
if not title:
title = tr('Pvtbox')
# Convert strings to unicode
if type(text) in (str, str):
text = ensure_unicode(text)
if type(title) in (str, str):
title = ensure_unicode(title)
logger.info("show_tray_notification: %s, title: %s", text, title)
if self._tray.supportsMessages():
self._tray.showMessage(title, text)
else:
logger.warning("tray does not supports messages")
def request_to_user(
self, dialog_id, text, buttons=("Yes", "No"), title="",
close_button_index=-1, close_button_off=False, parent=None,
on_clicked_cb=None,
details=''):
msg_box = QMessageBox(parent)
# msg_box = QMessageBox()
if not title:
title = tr('Pvtbox')
msg_box.setWindowTitle(title)
msg_box.setText(str(text))
pvtboxIcon = QIcon(':/images/icon.png')
msg_box.setWindowIcon(pvtboxIcon)
if details:
msg_box.setDetailedText(details)
if close_button_off:
if get_platform() == 'Darwin':
msg_box.setWindowFlags(Qt.Tool)
else:
msg_box.setWindowFlags(Qt.Dialog |
Qt.CustomizeWindowHint |
Qt.WindowTitleHint)
msg_box.setAttribute(Qt.WA_MacFrameworkScaled)
msg_box.setModal(True)
buttons = list(buttons)
for button in buttons:
msg_box.addButton(button, QMessageBox.ActionRole)
msg_box.show()
msg_box.raise_()
msg_box.exec_()
try:
button_index = buttons.index(msg_box.clickedButton().text())
except (ValueError, AttributeError):
button_index = -1
# message box was closed with close button
if len(buttons) == 1 and close_button_index == -1:
# if only one button then call callback
close_button_index = 0
if len(buttons) > close_button_index >= 0:
button_index = close_button_index
if button_index >= 0 and callable(on_clicked_cb):
on_clicked_cb(dialog_id, button_index)
def update_status_icon(self, new_status, new_substatus):
icon = self._icons[STATUS_DISCONNECTED] if new_status == STATUS_INIT \
else self._icons[new_status]
self._tray.setIcon(icon)
tool_tip = self._statuses[new_status]
if new_status == STATUS_IN_WORK and new_substatus == SUBSTATUS_SHARE:
tool_tip = tr("Pvtbox downloading share...")
self.set_tool_tip(tool_tip)
self.show()
def show(self):
self._tray.setVisible(True)
self._tray.show()
def hide(self):
if self._tray_show_timer.isActive():
self._tray_show_timer.stop()
self._tray.hide()
def __del__(self):
self._tray.removeEventFilter(self)
self._tray.activated.disconnect()
self.hide()
class App:
killSignal = signal.SIGUSR1
def __init__(self):
# Qt application creation.
self.qApp = QApplication(sys.argv)
# System tray icon menu creation.
menu = QMenu()
showMainWindowAction = menu.addAction(_('Show %s window') % (APP_NAME))
showMainWindowAction.triggered.connect(self.showMainWindow)
menu.addSeparator()
exitAction = menu.addAction(_('Exit'))
exitAction.triggered.connect(self._quit)
# System tray icon creation.
self.tray = QSystemTrayIcon()
self.tray.setIcon(QIcon(self.getResourceFile(APP_ICON)))
self.tray.setContextMenu(menu)
self.tray.show()
self.tray.setToolTip(APP_NAME)
self.tray.activated.connect(self._iconActivated)
# QWebEngineView to handle external urls opening.
self.wevExternalUrl = QWebEngineView()
def _download(self, download):
filename = QFileDialog.getSaveFileName(None, _('Save as'),
download.path(), "")
if (filename[0] == ''):
download.cancel()
else:
download.setPath(filename[0])
download.accept()
def _iconActivated(self, reason):
if (reason == QSystemTrayIcon.Trigger):
self.toggleVisible()
def _kill(self):
if (self.killSignal == signal.SIGUSR1):
self.killSignal = signal.SIGTERM
elif (self.killSignal == signal.SIGTERM):
self.killSignal = signal.SIGKILL
print('Killing...')
os.killpg(0, self.killSignal)
def _launchExternalUrl(self, url):
self.wevExternalUrl.urlChanged.disconnect(self._launchExternalUrl)
_EOU(url.toString())
def _quit(self, checked):
# Sometimes QtWebEngineProcess hangs and next code is a work around.
self.timer = QTimer()
self.timer.timeout.connect(self._kill)
self.timer.start(5000 * 10) # Two seconds for mercy.
sys.exit()
def getResourceFile(self, fileName):
fileNameAux = fileName.lower()
if (fileNameAux == APP_ICON):
fileName = os.path.join(_PR2A('desktop'), 'Juasap.png')
return fileName
def hideMainWindow(self):
self.mainWindow.hide()
def run(self):
self.mainWindow = MainWindow()
availableGeometry = self.qApp.desktop().availableGeometry(
self.mainWindow)
self.mainWindow.resize(availableGeometry.width() * 0.40,
availableGeometry.height() * 0.90)
self.mainWindow.show()
def showMainWindow(self):
self.mainWindow.show()
def toggleVisible(self):
if self.mainWindow.isVisible():
self.hideMainWindow()
else:
self.showMainWindow()
class MainWindow(QWidget):
def __init__(self):
QWidget.__init__(self)
self.reminders = None
self.active_reminder = None
self.initialize_db()
self.tray_icon = QSystemTrayIcon(self)
self.tray_menu = QMenu()
self.initialize_tray_icon()
self.disambiguate_timer = QTimer(self)
self.disambiguate_timer.setSingleShot(True)
self.disambiguate_timer.timeout.connect(
self.disambiguate_timer_timeout)
self.view_reminders_button = QPushButton('View')
self.view_reminders_button.clicked.connect(
self.on_view_reminders_button_clicked)
self.new_reminder_button = QPushButton('New')
self.new_reminder_button.clicked.connect(
self.on_new_reminder_button_clicked)
self.random_reminder_button = QPushButton('Random Reminder')
self.random_reminder_button.clicked.connect(
self.on_random_reminder_button_clicked)
self.reminder_text = QLabel(self.active_reminder)
self.reminder_text.setAlignment(Qt.AlignCenter)
self.v_box = QVBoxLayout()
self.h_box1 = QHBoxLayout()
self.h_box1.addWidget(self.view_reminders_button,
alignment=Qt.AlignLeft)
self.h_box1.addWidget(self.new_reminder_button,
alignment=Qt.AlignRight)
self.h_box2 = QHBoxLayout()
self.h_box2.addWidget(self.reminder_text)
self.h_box3 = QHBoxLayout()
self.h_box3.addWidget(self.random_reminder_button,
alignment=Qt.AlignHCenter)
self.v_box.addLayout(self.h_box1)
self.v_box.addLayout(self.h_box2)
self.v_box.addLayout(self.h_box3)
self.setLayout(self.v_box)
self.popup = QMessageBox()
self.popup.setText(self.active_reminder)
self.new_reminder_window = NewReminderWindow()
self.new_reminder_window.save_button.clicked.connect(
self.on_save_clicked)
self.view_reminders_window = ViewRemindersWindow()
@Slot()
def on_random_reminder_button_clicked(self):
self.choose_random_reminder()
@Slot()
def on_new_reminder_button_clicked(self):
self.new_reminder_window.show()
self.new_reminder_window.new_reminder_text_input.setFocus()
@Slot()
def on_view_reminders_button_clicked(self):
for reminder in db.get_reminders():
self.view_reminders_window.reminders_list.addItem(reminder[1])
self.view_reminders_window.show()
@Slot()
def disambiguate_timer_timeout(self):
print('single click')
@Slot()
def on_save_clicked(self):
db.save_new_reminder(
self.new_reminder_window.new_reminder_text_input.toPlainText())
self.new_reminder_window.new_reminder_text_input.clear()
self.new_reminder_window.hide()
@Slot()
def on_tray_icon_activated(self, reason):
if reason == QSystemTrayIcon.Trigger:
self.disambiguate_timer.start(150)
elif reason == QSystemTrayIcon.DoubleClick:
self.disambiguate_timer.stop()
print('double click')
def initialize_db(self):
db.initialize()
self.reminders = db.get_reminders()
if len(self.reminders):
self.active_reminder = random.choice(self.reminders)[1]
else:
self.active_reminder = 'No saved reminders. Try adding one now :)'
def initialize_tray_icon(self):
self.tray_icon.setIcon(QIcon('./assets/icon.png'))
self.tray_icon.activated.connect(self.on_tray_icon_activated)
self.tray_icon.setToolTip(self.active_reminder)
self.tray_icon.show()
exit_action = self.tray_menu.addAction('Exit')
exit_action.triggered.connect(sys.exit)
self.tray_icon.setContextMenu(self.tray_menu)
def choose_random_reminder(self):
if not len(self.reminders):
self.show_alert('Please add a new reminder.')
return
self.active_reminder = random.choice(self.reminders)
self.reminder_text.setText(self.active_reminder[1])
self.popup.setText(self.active_reminder[1])
self.tray_icon.setToolTip(self.active_reminder[1])
def show_alert(self, text):
self.popup.setText(text)
self.popup.show()
class Indicator():
APP_NAME = 'FortiVPN Quick Tray'
def __init__(self):
self.app = QApplication([])
self.app.setQuitOnLastWindowClosed(False)
self.indicator = QSystemTrayIcon()
self.indicator.setIcon(QIcon(self._get_file('./icons/icon.png')))
self.indicator.setContextMenu(self._build_menu())
self.indicator.setVisible(True)
self.indicator.setToolTip('OFF')
self.indicator.activated.connect(self._click_indicator)
self.logs_dialog = QTextEdit()
self.logs_dialog.setWindowTitle(f'{self.APP_NAME} - Logs')
self.logs_dialog.setFixedSize(440, 440)
self.logs_dialog.setReadOnly(True)
self.logs_dialog.setWindowIcon(
QIcon(self._get_file('./icons/icon.png')))
self.vpn_config = '/etc/openfortivpn/config'
self.vpn_process = None
self.vpn_logs_file = NamedTemporaryFile(delete=False)
def run(self):
self.app.exec_()
sys.exit()
def _build_menu(self):
menu = QMenu()
self.connect_action = QAction('Connect')
self.disconnect_action = QAction('Diconnect')
self.config_action = QAction('Config')
self.logs_action = QAction('Logs')
self.exit_action = QAction('Exit')
self.disconnect_action.setDisabled(True)
self.connect_action.triggered.connect(self._click_connect)
self.disconnect_action.triggered.connect(self._click_disconnect)
self.config_action.triggered.connect(self._click_config)
self.logs_action.triggered.connect(self._click_logs)
self.exit_action.triggered.connect(self._click_exit)
menu.addAction(self.connect_action)
menu.addAction(self.disconnect_action)
menu.addSeparator()
menu.addAction(self.config_action)
menu.addAction(self.logs_action)
menu.addSeparator()
menu.addAction(self.exit_action)
return menu
def _click_connect(self):
self.indicator.setIcon(QIcon(self._get_file('./icons/try.png')))
self.indicator.setToolTip('TRYING')
self.connect_action.setDisabled(True)
self.config_action.setDisabled(True)
with open(self.vpn_logs_file.name, 'w+b') as f:
try:
self.vpn_process = Popen(split('pkexec openfortivpn -c ' +
self.vpn_config),
stdin=PIPE,
stdout=f,
stderr=f)
self.vpn_process.communicate(timeout=1)
except TimeoutExpired:
pass
vpn_process_thread = Thread(target=self._monitor_logs, daemon=True)
vpn_process_thread.start()
def _click_disconnect(self):
try:
run(split('pkexec kill ' + str(self.vpn_process.pid)))
except ChildProcessError:
pass
def _click_config(self):
config_file, _ = QFileDialog.getOpenFileName(
caption='Select config file',
dir='/',
filter='All files (*)',
options=QFileDialog.DontUseNativeDialog)
if config_file:
self.vpn_config = config_file
def _click_logs(self):
with open(self.vpn_logs_file.name) as logs:
self.logs_dialog.setPlainText(logs.read())
self.logs_dialog.show()
def _click_exit(self):
if self.indicator.toolTip() == 'ON':
_ = QMessageBox.warning(
None, self.APP_NAME,
'VPN is still ON. Please Disconnect first before exiting')
return
if self.vpn_logs_file.name:
remove_log_file(self.vpn_logs_file.name)
self.app.quit()
def _monitor_logs(self):
with open(self.vpn_logs_file.name) as f:
while True:
line = f.readline()
if line.find('Error') != -1 or line.find('ERROR') != -1:
self.indicator.setIcon(
QIcon(self._get_file('./icons/err.png')))
self.indicator.setToolTip('ERROR')
self.connect_action.setDisabled(False)
self.config_action.setDisabled(False)
break
if line.find('Tunnel is up and running') != -1:
self.indicator.setIcon(
QIcon(self._get_file('./icons/on.png')))
self.indicator.setToolTip('ON')
self.disconnect_action.setDisabled(False)
if line.find('Logged out') != -1:
self.indicator.setIcon(
QIcon(self._get_file('./icons/icon.png')))
self.indicator.setToolTip('OFF')
self.disconnect_action.setDisabled(True)
self.connect_action.setDisabled(False)
self.config_action.setDisabled(False)
break
sleep(0.1)
def _get_file(self, file_path):
try:
base = sys._MEIPASS
except Exception:
base = path.abspath('.')
return path.join(base, file_path)
def _click_indicator(self, event):
if event == QSystemTrayIcon.ActivationReason.Trigger:
self._click_logs()
class SystemTray:
tray_icon: QSystemTrayIcon
tray_menu: QMenu
def set_use_systemtray(self):
use_systemtray = not self.switcher.settings.get("use_systemtray")
self.switcher.settings["use_systemtray"] = use_systemtray
self.switcher.settings_write()
if use_systemtray:
self.tray_icon.show()
else:
self.tray_icon.hide()
def systemtray(self, parent=None):
self.tray_menu = QMenu(parent)
self.tray_icon = QSystemTrayIcon(QIcon("logo.png"))
self.tray_icon.setToolTip(
_("Program to quickly switch between steam accounts"))
login_menu = QMenu(_("Login with"))
self.tray_menu.addMenu(login_menu)
def populate_login_menu():
login_menu.clear()
menu_accounts = []
accounts, avatars = self.load_accounts(no_populate=True)
if not accounts:
login_menu.setEnabled(False)
else:
login_menu.setEnabled(True)
for login_name, user in accounts:
menu_accounts.append(
QAction(user.get("steam_name", login_name),
self,
data=str(login_name)))
menu_accounts[-1].setToolTip(
"Login with {0}".format(login_name))
if self.switcher.settings["show_avatars"]:
menu_accounts[-1].setIcon(
QIcon(
avatars.get(login_name,
self.switcher.default_avatar)))
menu_accounts[-1].triggered.connect(
lambda: self.steam_login(str(menu_accounts[-1].data()),
True))
login_menu.addActions(menu_accounts)
def activated(reason):
self.tray_menu.addMenu(TopBar.settings_menu)
self.tray_menu.addSeparator()
self.tray_menu.addAction(_("Exit"), self.exit_app)
self.tray_icon.setContextMenu(self.tray_menu)
if reason == QSystemTrayIcon.Trigger:
if self.isVisible():
self.hide()
else:
self.show()
else:
populate_login_menu()
self.tray_icon.activated.connect(activated)
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()
