class FilteredTable(QWidget):
def __init__(self, parent):
super(FilteredTable, self).__init__(parent)
self.model = QStandardItemModel(600, 600)
for i in range(self.model.rowCount()):
for j in range(self.model.columnCount()):
self.model.setData(self.model.index(i, j), str(i * j),
Qt.DisplayRole)
self.m = FilteringModel(self)
self.m.setSourceModel(self.model)
d = ['a'] * 300 + ['b'] * 200 + ['c'] * 99 + ['d']
self.m.setIndexData(d)
t = QTableView(self)
t.setModel(self.m)
self.line_in = QLineEdit(self)
self.line_in.textChanged.connect(self.m.setFilterFixedString)
l = QVBoxLayout()
l.addWidget(self.line_in)
l.addWidget(t)
self.setLayout(l)
class WeekViewWidget(SubFrame):
def __init__(self, parent):
super(WeekViewWidget, self).__init__("Week", None, parent)
self._table_model = QStandardItemModel(1, 2, None)
self._table_model.setHorizontalHeaderLabels(
[_("# Ord."), _("Customer")])
self.table_view = LeftRightTableView(self)
self.table_view.setModel(self._table_model)
self.table_view.verticalHeader().hide()
self.table_view.setAlternatingRowColors(True)
self.table_view.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table_view.setSelectionMode(QAbstractItemView.SingleSelection)
self.table_view.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.table_view.horizontalHeader().setResizeMode(
0, QHeaderView.ResizeToContents)
self.table_view.horizontalHeader().setStretchLastSection(True)
self.preorder_brush = QBrush(QColor(255, 255, 128))
self.completed_order_brush = QBrush(QColor(128, 255, 128))
self.layout().addWidget(self.table_view)
def _set_last_row(self, data, role):
for i in range(self._table_model.columnCount()):
self._table_model.setData(
self._table_model.index(self._table_model.rowCount() - 1, i),
data, role)
def set_data(self, data, base_date):
self.set_title(date_to_dm(base_date))
self._table_model.removeRows(0, self._table_model.rowCount())
current_ndx = 0
for d in data:
order, customer_name = d
number = order.preorder_label
if order.accounting_label:
number = order.accounting_label
self._table_model.appendRow(
[QStandardItem(str(number)),
QStandardItem(customer_name)])
self._table_model.setData(self._table_model.index(current_ndx, 0),
order.order_id, Qt.UserRole)
if order.state == OrderStatusType.order_completed:
self._set_last_row(self.completed_order_brush,
Qt.BackgroundRole)
elif order.state == OrderStatusType.preorder_definition:
self._set_last_row(self.preorder_brush, Qt.BackgroundRole)
current_ndx += 1
# Not the slightest idea why this works
# and not resizeColumnsToContents
for i in range(self._table_model.columnCount()):
self.table_view.resizeColumnToContents(i)
class PriorityCombo(QComboBox):
def __init__(self,parent=None):
super(PriorityCombo, self).__init__(parent)
self.model = QStandardItemModel(len(priority_stars()), 1)
for i,stars in priority_stars():
ndx = self.model.index( i-1, 0)
self.model.setData( ndx, stars, Qt.DisplayRole)
self.model.setData( ndx, i, Qt.UserRole)
self.setModel( self.model)
def current_priority(self):
return self.currentIndex().data(Qt.UserRole)
class PythonEnumComboDelegate(StandardTableDelegate):
""" The combo delegates will provide a drop down based editor for fixed enumerations.
When in display mode, it will work as a simple label.
When in edit mode, the delegate operates on the UserRole
of the model (so that one can link the actual text
representation with the object it represents)
"""
# The combo box content is given by a model that
# uses the DisplayRole for the labels and the UserRole for the data
def __init__(self, enumeration, parent=None):
StandardTableDelegate.__init__(self, parent)
assert issubclass(enumeration, enum.Enum)
# We expect : symbol = description (short), description (long)
self.model = QStandardItemModel(len(enumeration), 1)
i = 0
for item in enumeration:
self.model.setData(self.model.index(i, 0), item.value,
Qt.DisplayRole)
self.model.setData(self.model.index(i, 0), item, Qt.UserRole)
i += 1
def get_displayed_data(self, index):
e = index.model().data(index, Qt.UserRole)
if e:
return e.value
else:
return None
def setEditorData(self, editor, index):
# We provide a suitable default is the source data is null
# (which is : leave the index on the first line of the combo)
# Find the source data in our combo model so that we can
# preselect it on the combo
m = editor.model()
# Read the source data at the index of the source model
data = index.model().data(index, Qt.UserRole)
if data:
for i in range(m.rowCount()):
if m.data(m.index(i, 0), Qt.UserRole) == data:
editor.setCurrentIndex(i)
return
def setModelData(self, editor, model, index):
data = editor.itemData(editor.currentIndex()) # by default Qt.UserRole
model.setData(index, data, Qt.UserRole)
def createEditor(self, parent, option, index):
# Qt takes ownership of the editor
# Therefore I have recreate it each time this method is called
combo = AutoCompleteComboBox2(parent)
combo.setModel(self.model)
completer = QCompleter(combo)
completer.setModel(self.model)
completer.setCompletionMode(
QCompleter.UnfilteredPopupCompletion) # PopupCompletion)
combo.setCompleter(completer)
if option:
# This is needed to put the combobox in the right place
combo.setGeometry(option.rect)
return combo
class PresenceOverviewWidget(HorsePanel):
@Slot(QModelIndex)
def cell_entered(self, ndx):
employee_id = self._employee_id_on_row(ndx)
if not employee_id:
self._show_totals_day_off(None)
elif employee_id:
chrono.chrono_start()
employee = None
for i in self.employees:
if i.employee_id == employee_id:
employee = i
break
self.detail_subframe.set_title(employee.fullname)
self._show_totals_day_off(employee_id)
d = date(
self.base_date.year, self.base_date.month,
min(
calendar.monthrange(self.base_date.year,
self.base_date.month)[1],
max(1, ndx.column())))
chrono.chrono_click("Retrieveing data")
tars = dao.task_action_report_dao.get_reports_for_employee_id_on_date(
employee_id, d)
work_timetracks = dao.timetrack_dao.all_work_for_employee_date_manual(
employee_id, d)
presence_timetracks = dao.timetrack_dao.all_presence_for_employee_date_managed_by_code_full(
employee_id, d)
# employee = dao.employee_dao.find_by_id(employee_id)
special_activities = dao.special_activity_dao.find_on_day(
employee_id, d)
chrono.chrono_click("Redrawing")
self.time_report_view.redraw(datetime(d.year, d.month, d.day, 6,
0),
tars,
employee_id,
work_timetracks,
presence_timetracks,
special_activities,
view_title=_("Work on {}").format(
date_to_dmy(d, full_month=True)))
session().close(
) # FIXME Put his one line above; but that's tough ! SQLA doesn't help us much here !
chrono.chrono_click("Session closed")
# for event_type, duration in self.day_event_totals[employee_id].items():
# mainlog.debug("{}{}".format(event_type, duration))
self._toggle_days_off_actions()
def _employee_id_on_row(self, row_or_ndx):
r = row_or_ndx
if type(r) != int:
r = row_or_ndx.row()
return self._table_model.data(self._table_model.index(r, 0),
Qt.UserRole)
DAY_EVENT_PALETTE = {
DayEventType.holidays: (Qt.GlobalColor.white, Qt.GlobalColor.red),
DayEventType.day_off: (Qt.GlobalColor.white, Qt.GlobalColor.darkRed),
DayEventType.unpaid_day_off:
(Qt.GlobalColor.black, Qt.GlobalColor.magenta),
DayEventType.free_day:
(Qt.GlobalColor.white, Qt.GlobalColor.darkMagenta),
DayEventType.overtime: (Qt.GlobalColor.black, Qt.GlobalColor.green),
DayEventType.recuperation:
(Qt.GlobalColor.white, Qt.GlobalColor.darkGreen),
DayEventType.unemployment: (Qt.GlobalColor.white, Qt.GlobalColor.blue),
DayEventType.unemployment_short:
(Qt.GlobalColor.white, Qt.GlobalColor.darkBlue),
DayEventType.work_accident: (Qt.GlobalColor.black,
Qt.GlobalColor.yellow),
DayEventType.sick_leave: (Qt.GlobalColor.white,
Qt.GlobalColor.darkYellow)
}
MONTH_EVENT_COLUMN = 2
YEAR_EVENT_COLUMN = 3
def _make_total_days_off_panel(self):
widget = QFrame()
widget.setObjectName('HorseRegularFrame')
widget.setFrameShape(QFrame.Panel)
widget.setFrameShadow(QFrame.Sunken)
layout = QVBoxLayout()
#layout.addWidget(QLabel(_("Days off to date")))
self.day_off_total_duration_labels = dict()
self.day_off_month_duration_labels = dict()
self.day_off_labels = dict()
self._day_off_table_model = QStandardItemModel(10, 3)
self._day_off_table_model.setHorizontalHeaderLabels(
[None, None, _("This\nmonth"),
_("Before")])
self.day_off_table_view = QTableView(None)
self.day_off_table_view.setModel(self._day_off_table_model)
# self.day_off_table_view.setHorizontalHeader(self.headers_view)
self.day_off_table_view.verticalHeader().hide()
self.day_off_table_view.setAlternatingRowColors(True)
self.day_off_table_view.setEditTriggers(
QAbstractItemView.NoEditTriggers)
self.day_off_table_view.hide()
row = 0
for det in DayEventType.symbols():
ndx = self._day_off_table_model.index(row, 0)
self._day_off_table_model.setData(ndx, det.description,
Qt.DisplayRole)
ndx = self._day_off_table_model.index(row, 1)
fg, bg = self.DAY_EVENT_PALETTE[det]
self._day_off_table_model.setData(ndx, QBrush(bg),
Qt.BackgroundRole)
self._day_off_table_model.setData(ndx, QBrush(fg),
Qt.TextColorRole)
self._day_off_table_model.setData(ndx,
DayEventType.short_code(det),
Qt.DisplayRole)
row += 1
layout.addWidget(self.day_off_table_view)
grid = QGridLayout()
self.days_off_layout = grid
grid.setColumnStretch(3, 1)
row = 0
grid.addWidget(QLabel(_('Year')), row, self.YEAR_EVENT_COLUMN)
grid.addWidget(QLabel(_('Month')), row, self.MONTH_EVENT_COLUMN)
row += 1
for det in DayEventType.symbols():
self.day_off_total_duration_labels[det] = QLabel("-")
self.day_off_month_duration_labels[det] = QLabel("-")
self.day_off_labels[det] = QLabel(det.description)
hlayout = QHBoxLayout()
sl = QLabel()
fg, bg = self.DAY_EVENT_PALETTE[det]
def to_html_rgb(color):
i = color.red() * 256 * 256 + color.green() * 256 + color.blue(
)
return "#{:06X}".format(i)
p = QPalette()
p.setColor(QPalette.Window, QColor(bg))
p.setColor(QPalette.WindowText, QColor(fg))
sl.setPalette(p)
sl.setAlignment(Qt.AlignCenter)
sl.setStyleSheet("border: 2px solid black; background: {}".format(
to_html_rgb(QColor(bg))))
t = DayEventType.short_code(det)
mainlog.debug(t)
sl.setAutoFillBackground(True)
sl.setText(t)
grid.addWidget(sl, row, 0)
grid.addWidget(self.day_off_labels[det], row, 1)
grid.addWidget(self.day_off_total_duration_labels[det], row,
self.YEAR_EVENT_COLUMN)
grid.addWidget(self.day_off_month_duration_labels[det], row,
self.MONTH_EVENT_COLUMN)
hlayout.addStretch()
row += 1
layout.addLayout(grid)
layout.addStretch()
self.day_off_table_view.resizeColumnsToContents()
# self.day_off_table_view.setMinimumWidth( self.day_off_table_view.width())
# self.day_off_table_view.resize( self.day_off_table_view.minimumWidth(),
# self.day_off_table_view.minimumHeight(),)
widget.setLayout(layout)
return widget
def _show_totals_day_off(self, employee_id):
mainlog.debug("_show_totals_day_off : {}".format(employee_id))
def form_layout_row_set_visible(layout, row_ndx, is_visible):
for i in range(layout.columnCount()):
l = layout.itemAtPosition(row_ndx, i)
if l and l.widget():
l.widget().setVisible(is_visible)
det_to_show = dict()
row = 0
for det in DayEventType.symbols():
yearly = 0
if employee_id in self.all_events_in_year:
if det in self.all_events_in_year[employee_id]:
yearly = nice_round(
self.all_events_in_year[employee_id][det])
monthly = 0
if employee_id in self.day_event_totals:
if det in self.day_event_totals[employee_id]:
monthly = nice_round(
self.day_event_totals[employee_id][det])
# ndx = self._day_off_table_model.index(row,self.YEAR_EVENT_COLUMN)
# self._day_off_table_model.setData(ndx, v, Qt.DisplayRole)
if yearly or monthly:
det_to_show[det] = {'monthly': monthly, 'yearly': yearly}
if det_to_show:
# If there are some days spent on some counters, then we display
# those counters *only*
mainlog.debug("_show_totals_day_off : showing some events ".format(
str(det_to_show)))
row = 0
for det in DayEventType.symbols():
if det in det_to_show:
monthly = det_to_show[det]['monthly']
yearly = det_to_show[det]['yearly']
form_layout_row_set_visible(self.days_off_layout, row + 1,
True)
self.day_off_total_duration_labels[det].setText(yearly
or '-')
self.day_off_month_duration_labels[det].setText(monthly
or '-')
else:
form_layout_row_set_visible(self.days_off_layout, row + 1,
False)
else:
# If there are no days spent on any counter, then we display
# all counters at the 0 mark.
mainlog.debug("_show_totals_day_off : showing no event")
row = 0
for det in DayEventType.symbols():
form_layout_row_set_visible(self.days_off_layout, row + 1,
True)
row += 1
# self.day_off_table_view.resizeColumnsToContents()
self.days_off_panel.parent().update()
@Slot()
def refresh_action(self):
global dao
# mainlog.debug("refresh action started")
self.hours_per_pers_subframe.set_title(date_to_my(
self.base_date, True))
chrono.chrono_start()
all_events_in_month = people_admin_service.events_for_month(
self.base_date)
employee_with_events = [
event.employee_id for event in all_events_in_month
]
# mainlog.debug(all_events_in_month)
self.all_events_in_year = people_admin_service.events_for_year(
self.base_date.year)
self.all_presences = all_presences = dao.employee_dao.presence_overview_for_month(
self.base_date)
all_correction_times = dict()
for s in dao.month_time_synthesis_dao.load_all_synthesis(
self.base_date.year, self.base_date.month):
all_correction_times[s.employee_id] = s.correction_time
special_activities = dao.special_activity_dao.find_on_month(
self.base_date)
employees = list(
filter(
lambda e: e.is_active or e.employee_id in all_presences or e.
employee_id in all_correction_times or e.employee_id in
special_activities or e.employee_id in employee_with_events,
dao.employee_dao.list_overview()))
self.employees = employees
chrono.chrono_click()
day_max = calendar.monthrange(self.base_date.year,
self.base_date.month)[1]
t_start = datetime(self.base_date.year, self.base_date.month, 1)
t_end = datetime(self.base_date.year, self.base_date.month, day_max,
23, 59, 59, 999999)
self._table_model.setRowCount(len(employees))
self._table_model.setColumnCount(1 + day_max + 3)
headers = QStandardItemModel(1, 1 + day_max + 3)
headers.setHeaderData(0, Qt.Orientation.Horizontal, _("Employee"))
for i in range(day_max):
headers.setHeaderData(i + 1, Qt.Orientation.Horizontal,
"{}".format(i + 1))
headers.setHeaderData(day_max + 1, Qt.Orientation.Horizontal,
_("Correction"))
headers.setHeaderData(day_max + 2, Qt.Orientation.Horizontal,
_("Total"))
headers.setHeaderData(day_max + 3, Qt.Orientation.Horizontal,
_("Days off"))
self.headers_view.setModel(
headers) # qt's doc : The view does *not* take ownership
self.header_model = headers
self.headers_view.setModel(
self.header_model) # qt's doc : The view does *not* take ownership
# Compute all mondays indices
monday = 0
if t_start.weekday() > 0:
monday = 7 - t_start.weekday()
all_mondays = []
while monday < day_max:
all_mondays.append(monday)
monday += 7
today = date.today()
# mainlog.debug("Running on employees")
for row in range(self._table_model.rowCount()):
# Clear the line
for col in range(0, 32):
ndx = self._table_model.index(row, col)
self._table_model.setData(ndx, None, Qt.BackgroundRole)
self._table_model.setData(ndx, QBrush(Qt.GlobalColor.black),
Qt.TextColorRole)
self._table_model.setData(ndx, None, Qt.DisplayRole)
self._table_model.setData(ndx, None, Qt.UserRole)
self._table_model.setData(ndx, None, Qt.UserRole + 1)
# else:
# self._table_model.setData(ndx,None,Qt.BackgroundRole)
# else:
# self._table_model.setData(ndx,None,Qt.DisplayRole)
# self._table_model.setData(ndx,None,Qt.BackgroundRole)
# Mark mondays
for col in all_mondays:
# col + 1 to account for the employee column
self._table_model.setData(
self._table_model.index(row, col + 1),
QBrush(QColor(230, 230, 255)), Qt.BackgroundRole)
# Mark today
if today.month == self.base_date.month and today.year == self.base_date.year:
self._table_model.setData(
self._table_model.index(row, today.day),
QBrush(QColor(255, 255, 128)), Qt.BackgroundRole)
row = 0
for employee in employees: # employees are sorted
self._table_model.setData(self._table_model.index(row, 0),
employee.fullname,
Qt.DisplayRole) # FIXME Use a delegate
self._table_model.setData(self._table_model.index(row, 0),
employee.employee_id,
Qt.UserRole) # FIXME Use a delegate
correction = 0
if employee.employee_id in all_correction_times:
correction = all_correction_times[employee.employee_id]
self._table_model.setData(
self._table_model.index(row, day_max + 1),
duration_to_hm(correction, short_unit=True),
Qt.DisplayRole)
else:
self._table_model.setData(
self._table_model.index(row, day_max + 1), None,
Qt.DisplayRole)
presence = 0
if employee.employee_id in all_presences and len(
all_presences[employee.employee_id]) > 0:
import functools
presence = functools.reduce(
lambda acc, s: acc + s,
all_presences[employee.employee_id], 0)
presence += correction
if presence != 0:
self._table_model.setData(ndx, QBrush(Qt.GlobalColor.black),
Qt.TextColorRole)
self._table_model.setData(
self._table_model.index(row, day_max + 2),
duration_to_hm(presence, short_unit=True), Qt.DisplayRole)
else:
self._table_model.setData(
self._table_model.index(row, day_max + 2), None,
Qt.DisplayRole)
if employee.employee_id in all_presences and len(
all_presences[employee.employee_id]) > 0:
for b in range(len(all_presences[employee.employee_id])):
ndx = self._table_model.index(row, b + 1)
p = all_presences[employee.employee_id][b]
if p > 0:
self._table_model.setData(
ndx, duration_to_hm(p, short_unit=True),
Qt.DisplayRole)
self._table_model.setData(ndx, p, Qt.UserRole)
if p >= 4 and p <= 8:
# Regular work load
self._table_model.setData(
ndx, QBrush(QColor(192, 255, 192)),
Qt.BackgroundRole)
elif p > 8 or (p < 4 and p > 0):
# Problematic work load
self._table_model.setData(
ndx, QBrush(QColor(255, 192, 192)),
Qt.BackgroundRole)
if employee.employee_id in special_activities:
sa_of_employee = special_activities[employee.employee_id]
for sa in sa_of_employee:
start = max(t_start, sa.start_time)
end = min(t_end, sa.end_time)
for i in range(start.day, end.day + 1):
ndx = self._table_model.index(row, i)
self._table_model.setData(ndx,
QBrush(QColor(255, 128, 0)),
Qt.BackgroundRole)
# self._table_model.setData(self._table_model.index(row,b+1),Qt.AlignRight | Qt.AlignVCenter,Qt.TextAlignmentRole)
row += 1
# Display day events
employee_id_to_row = dict() # little accelerator
for row in range(len(employees)):
employee_id_to_row[employees[row].employee_id] = row
# Compute days off totals and show them
self.day_event_totals = dict([(e.employee_id, dict())
for e in employees])
for day_event in all_events_in_month:
# mainlog.debug("employee_id = {}".format(day_event.employee_id))
# if day_event.employee_id not in self.day_event_totals:
# mainlog.debug(self.day_event_totals)
t = self.day_event_totals[day_event.employee_id]
if day_event.event_type not in t:
t[day_event.event_type] = day_event.duration
else:
t[day_event.event_type] += day_event.duration
for employee in employees: # employees are sorted
t = self.day_event_totals[employee.employee_id]
mainlog.debug(t)
total_off = sum(t.values())
mainlog.debug(total_off)
row = employee_id_to_row[employee.employee_id]
mainlog.debug(row)
if total_off:
self._table_model.setData(
self._table_model.index(row, day_max + 3),
nice_round(total_off), Qt.DisplayRole)
else:
self._table_model.setData(
self._table_model.index(row, day_max + 3), None,
Qt.DisplayRole)
# Show days off
for day_event in all_events_in_month:
row = employee_id_to_row[day_event.employee_id]
col = day_event.date.day
fg = bg = None
if day_event.event_type in self.DAY_EVENT_PALETTE:
fg, bg = self.DAY_EVENT_PALETTE[day_event.event_type]
else:
fg, bg = Qt.GlobalColor.red, Qt.GlobalColor.gray
ndx = self._table_model.index(row, col)
self._table_model.setData(ndx, day_event.day_event_id,
Qt.UserRole + 1)
# The problem here is to nicely blend the fact
# that you can have a day event mixed with actual work
# the very same day. Here's a poor man solution.
active_time = self._table_model.data(ndx, Qt.UserRole)
if not active_time:
self._table_model.setData(
ndx, DayEventType.short_code(day_event.event_type),
Qt.DisplayRole)
self._table_model.setData(ndx, QBrush(fg), Qt.TextColorRole)
self._table_model.setData(ndx, QBrush(bg), Qt.BackgroundRole)
else:
self._table_model.setData(ndx, QBrush(fg), Qt.TextColorRole)
self._table_model.setData(ndx, QBrush(bg), Qt.BackgroundRole)
self._table_model.setData(
ndx,
duration_to_hm(active_time, short_unit=True) +
DayEventType.short_code(day_event.event_type),
Qt.DisplayRole)
chrono.chrono_click()
#for i in range(len(all_mondays)):
self.table_view.resizeColumnsToContents()
# mainlog.debug("Reset selection")
ndx = self.table_view.currentIndex()
self.table_view.selectionModel().clear()
# self.table_view.selectionModel().clearSelection()
# self.table_view.selectionModel().select( self.table_view.model().index(ndx.row(),ndx.column()), QItemSelectionModel.Select)
# self.table_view.selectionModel().select( self.table_view.model().index(ndx.row(),ndx.column()), QItemSelectionModel.Select)
self.table_view.selectionModel().setCurrentIndex(
self.table_view.model().index(ndx.row(), ndx.column()),
QItemSelectionModel.Select)
self.cell_entered(self.table_view.currentIndex())
@Slot()
def edit_tars(self):
employee_id = self._employee_id_on_row(self.table_view.currentIndex())
d = date(
self.base_date.year, self.base_date.month,
min(
calendar.monthrange(self.base_date.year,
self.base_date.month)[1],
max(1, ndx.column())))
dialog = TimeReportingScannerDialog(self)
dialog.set_data(datetime(d.year, d.month, d.day, 6, 0), employee_id)
dialog.exec_()
if dialog.result() == QDialog.Accepted:
# pub.sendMessage('time_report.changed')
self.timetrack_changed.emit()
self.refresh_action()
@Slot()
def show_actions(self):
button = self.action_menu.parent()
p = button.mapToGlobal(QPoint(0, button.height()))
self.action_menu.exec_(p)
@Slot()
def delete_holidays(self):
ndx = self.table_view.currentIndex()
employee_id = self._employee_id_on_row(ndx)
d = date(self.base_date.year, self.base_date.month, ndx.column())
if dao.special_activity_dao.delete_by_employee_and_date(
employee_id, d):
self.refresh_panel()
@Slot()
def create_holidays(self):
employee_id = self._employee_id_on_row(self.table_view.currentIndex())
left_col = 1000
right_col = 0
for ndx in self.table_view.selectionModel().selectedIndexes():
c = ndx.column()
left_col = min(c, left_col)
right_col = max(c, right_col)
d_start = date(
self.base_date.year, self.base_date.month,
min(
calendar.monthrange(self.base_date.year,
self.base_date.month)[1], max(1,
left_col)))
d_end = date(
self.base_date.year, self.base_date.month,
min(
calendar.monthrange(self.base_date.year,
self.base_date.month)[1],
max(1, right_col)))
dialog = HolidaysDialog(self)
sa = SpecialActivity()
sa.employee_id = employee_id
sa.reporter_id = user_session.user_id
sa.encoding_date = date.today()
sa.start_time = datetime(d_start.year, d_start.month, d_start.day, 6,
0)
sa.end_time = datetime(d_end.year, d_end.month, d_end.day, 14, 0)
dialog.setup(sa, dao.employee_dao.find_by_id(employee_id).fullname)
# dialog.set_data(employee,self.base_date,c)
dialog.exec_()
if dialog.result() == QDialog.Accepted:
dao.special_activity_dao.save(sa)
self.refresh_action()
@Slot()
def edit_month_correction(self):
employee_id = self._employee_id_on_row(self.table_view.currentIndex())
if employee_id:
employee = dao.employee_dao.find_by_id(employee_id)
c = dao.month_time_synthesis_dao.load_correction_time(
employee_id, self.base_date.year, self.base_date.month)
dialog = MonthTimeCorrectionDialog(self)
dialog.set_data(employee.fullname, self.base_date, c)
dialog.exec_()
if dialog.result() == QDialog.Accepted:
c = dao.month_time_synthesis_dao.save(employee_id,
self.base_date.year,
self.base_date.month,
dialog.correction_time)
self.refresh_action()
@Slot()
def month_today(self):
self.base_date = date.today()
self.refresh_action()
@Slot()
def month_before(self):
m = self.base_date.month
if m > 1:
self.base_date = date(self.base_date.year, m - 1, 1)
else:
self.base_date = date(self.base_date.year - 1, 12, 1)
self.refresh_action()
@Slot()
def month_after(self):
m = self.base_date.month
if self.base_date.year < date.today().year + 1 \
or m < date.today().month:
if m < 12:
self.base_date = date(self.base_date.year, m + 1, 1)
else:
self.base_date = date(self.base_date.year + 1, 1, 1)
self.refresh_action()
@Slot()
def edit_timetrack_no_ndx(self):
ndx = self.table_view.currentIndex()
if ndx.isValid() and ndx.column() >= 0 and ndx.row() >= 0:
self.edit_timetrack(ndx)
else:
showWarningBox(_("Can't edit"),
_("You must first select a day/person."))
timetrack_changed = Signal()
@Slot(QModelIndex)
def edit_timetrack(self, ndx):
global dao
global user_session
if ndx.column() >= 1:
edit_date = date(
self.base_date.year, self.base_date.month,
ndx.column()) # +1 already in because of employee's names
employee_id = self._employee_id_on_row(ndx)
tars = dao.task_action_report_dao.get_reports_for_employee_id_on_date(
employee_id, edit_date)
if len(tars) == 0:
d = EditTimeTracksDialog(self, dao, edit_date)
d.set_employee_and_date(employee_id, edit_date)
d.exec_()
if d.result() == QDialog.Accepted:
self.refresh_action()
self.timetrack_changed.emit()
d.deleteLater()
else:
edit_date = datetime(self.base_date.year,
self.base_date.month,
ndx.column(),
hour=6)
from koi.TimeReportingScanner import TimeReportingScannerDialog
d = TimeReportingScannerDialog(self)
d.set_data(edit_date, employee_id) # or 16
d.exec_()
if d.result() == QDialog.Accepted:
self.refresh_action()
self.timetrack_changed.emit()
d.deleteLater()
@Slot()
def editTaskActionReports(self):
if not user_session.has_any_roles(['TimeTrackModify']):
return
m = self.base_date.month
ndx = self.table_view.currentIndex()
if ndx.isValid() and ndx.column() >= 0 and ndx.row() >= 0:
edit_date = date(
self.base_date.year, m,
ndx.column()) # +1 already in because of employee's names
employee = self._table_model.data(
self._table_model.index(ndx.row(), 0),
Qt.UserRole) # FIXME Use a delegate
d = EditTaskActionReportsDialog(dao, self, edit_date)
d.set_employee_date(employee, edit_date)
d.exec_()
if d.result() == QDialog.Accepted:
self.refresh_action()
d.deleteLater()
else:
showWarningBox(_("Can't edit"),
_("You must first select a day/person."))
# @Slot(QModelIndex)
# def timetrack_changed(self,ndx):
# selected_timetrack = self.controller.model.object_at(ndx)
# # Update the colors in the timetrack views
# # to show what action reports correspond to the
# # selected timetrack
# self.controller_actions.model.current_timetrack = selected_timetrack
# self.controller_actions.model.beginResetModel()
# self.controller_actions.model.endResetModel()
# # Make sure the first of the action reports is shown in the
# # table
# action_reports = self.controller_actions.model.objects
# for i in range(len(action_reports)-1,-1,-1):
# if action_reports[i] and action_reports[i].timetrack == selected_timetrack:
# self.controller_actions.view.scrollTo(self.controller_actions.model.index(i,0))
# break
def _make_table_header(self):
pass
def __init__(self, parent, find_order_action_slot):
super(PresenceOverviewWidget, self).__init__(parent)
self.set_panel_title(_("Presence overview"))
self.base_date = date.today()
headers = QStandardItemModel(1, 31 + 3)
self._table_model = QStandardItemModel(1, 31 + 3, None)
self.headers_view = QHeaderView(Qt.Orientation.Horizontal, self)
self.header_model = headers
self.headers_view.setResizeMode(QHeaderView.ResizeToContents)
self.headers_view.setModel(
self.header_model) # qt's doc : The view does *not* take ownership
self.table_view = TableViewSignaledEvents(None)
self.table_view.setModel(self._table_model)
self.table_view.setHorizontalHeader(self.headers_view)
self.table_view.verticalHeader().hide()
self.table_view.setAlternatingRowColors(True)
self.table_view.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.table_view.setContextMenuPolicy(Qt.CustomContextMenu)
self.table_view.customContextMenuRequested.connect(
self.popup_context_menu)
self.copy_action = QAction(_("Copy order parts"), self.table_view)
self.copy_action.triggered.connect(self.copy_slot)
self.copy_action.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_C))
self.copy_action.setShortcutContext(Qt.WidgetWithChildrenShortcut)
self.table_view.addAction(self.copy_action)
self.select_all_action = QAction(_("Select all"), self.table_view)
self.select_all_action.triggered.connect(self.select_all_slot)
self.select_all_action.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_A))
self.select_all_action.setShortcutContext(
Qt.WidgetWithChildrenShortcut)
self.table_view.addAction(self.select_all_action)
# self.table_view.setSelectionBehavior(QAbstractItemView.SelectItems)
# self.table_view.setSelectionMode(QAbstractItemView.SingleSelection)
navbar = NavBar(self, [(_("Month before"), self.month_before),
(_("Today"), self.month_today),
(_("Action"), self.show_actions),
(_("Month after"), self.month_after),
(_("Find"), find_order_action_slot)])
self.action_menu = QMenu(navbar.buttons[2])
navbar.buttons[2].setObjectName("specialMenuButton")
navbar.buttons[4].setObjectName("specialMenuButton")
self._make_days_off_menu_and_action_group()
list_actions = [ # (_("Edit"),self.edit_tars, None, None),
(_("Edit"), self.edit_timetrack_no_ndx, None, None),
(_("Month correction"), self.edit_month_correction, None,
[RoleType.modify_monthly_time_track_correction]),
(self.days_off_menu, None), (self.copy_action, None),
(self.select_all_action, None)
]
# (_("Insert holidays"),self.create_holidays, None, None),
# (_("Delete holidays"),self.delete_holidays, None, None) ]
populate_menu(self.action_menu, self, list_actions)
# mainlog.debug("tile widget")
self.title_box = TitleWidget(_("Presence Overview"), self, navbar)
self.vlayout = QVBoxLayout(self)
self.vlayout.setObjectName("Vlayout")
self.vlayout.addWidget(self.title_box)
self.hours_per_pers_subframe = SubFrame(_("Overview"), self.table_view,
self)
self.vlayout.addWidget(self.hours_per_pers_subframe)
self.time_report_view = TimeReportView(self)
self.days_off_panel = self._make_total_days_off_panel()
vbox = QVBoxLayout()
vbox.addWidget(self.days_off_panel)
vbox.addStretch()
vbox.setStretch(0, 0)
vbox.setStretch(1, 1)
hlayout = QHBoxLayout()
hlayout.addWidget(self.time_report_view)
hlayout.addLayout(vbox)
hlayout.setStretch(0, 1)
self.detail_subframe = SubFrame(_("Day"), hlayout, self)
self.vlayout.addWidget(self.detail_subframe)
self.setLayout(self.vlayout)
# dbox = QVBoxLayout()
# dbox.addWidget(QLabel("kjkljkj"))
# self.total_active_hours = LabeledValue(_("Total activity"))
# dbox.addWidget(self.total_active_hours)
# hbox = QHBoxLayout()
# hbox.addWidget(self.table_view)
# hbox.addLayout(dbox)
# self.selection_model = self.table_view.selectionModel()
# mainlog.debug(m)
#sm = QItemSelectionModel(self.table_view.model())
#sm.setModel(self.table_view.model())
# self.table_view.setSelectionModel(self.selection_model)
self.table_view.selectionModel().currentChanged.connect(
self.cell_entered)
self.table_view.doubleClickedCell.connect(self.edit_timetrack)
def _selection_to_period(self):
left_col = 1000
right_col = 0
for ndx in self.table_view.selectionModel().selectedIndexes():
c = ndx.column()
left_col = min(c, left_col)
right_col = max(c, right_col)
d_start = date(
self.base_date.year, self.base_date.month,
min(
calendar.monthrange(self.base_date.year,
self.base_date.month)[1], max(1,
left_col)))
d_end = date(
self.base_date.year, self.base_date.month,
min(
calendar.monthrange(self.base_date.year,
self.base_date.month)[1],
max(1, right_col)))
return d_start, d_end
def _toggle_days_off_actions(self):
day_max = calendar.monthrange(self.base_date.year,
self.base_date.month)[1]
ndx = self.table_view.currentIndex()
can_add = can_remove = False
if ndx.column() >= 1 and ndx.column() <= day_max:
day_event_id = ndx.data(Qt.UserRole + 1)
can_add = True
# if not day_event_id:
# day = ndx.column() - 1
#
# employee_id = self._employee_id_on_row(ndx)
# if employee_id in self.all_presences:
# if not self.all_presences[employee_id][day]:
# can_add = True
# else:
# can_add = True
# else:
# can_add = True
can_remove = day_event_id is not None
self.days_off_add_submenu.setEnabled(can_add)
for actions in self.days_off_action_group.actions():
actions.setEnabled(can_add)
self.day_off_remove_action.setEnabled(can_remove)
def _add_day_off(self, action):
if action.data() != 'Remove':
day_event_type, day_event_duration = action.data()
day_event_type = DayEventType.from_str(day_event_type)
mainlog.debug("selected action {} {}".format(
day_event_type, day_event_duration))
ndx = self.table_view.currentIndex()
day_event_id = ndx.data(Qt.UserRole + 1)
# if day_event_id:
# showWarningBox(_("There's already a day off here"))
# return
employee_id = self._employee_id_on_row(ndx)
if employee_id in self.all_presences:
day = ndx.column() - 1
mainlog.debug("_add_day_off : employee_id={}, day={}".format(
employee_id, day))
mainlog.debug(self.all_presences[employee_id])
mainlog.debug(type(self.all_presences[employee_id]))
# if self.all_presences[employee_id][day]:
# showWarningBox(_("One can't add day off where there is activity"))
# return
else:
mainlog.debug(
"_add_day_off : employee_id={} not yet known".format(
employee_id))
day_event = DayEvent()
day_event.employee_id = employee_id
day_event.event_type = day_event_type
day, last_day = self._selection_to_period()
if day_event_duration in (0.5, 1):
days_durations = [(day, day_event_duration)]
else:
days_durations = []
day, last_day = self._selection_to_period()
while day <= last_day:
days_durations.append(
(day, 1)) # One full work day on the day
day += timedelta(1)
# mainlog.debug(days_durations)
mainlog.debug("Creating day event of type {}".format(
day_event.event_type))
try:
people_admin_service.set_event_on_days(day_event,
days_durations)
except ServerException as ex:
showErrorBox(ex.translated_message)
self.refresh_action()
def _remove_day_off(self):
# Grab all the selected events
event_ids = []
for ndx in self.table_view.selectionModel().selectedIndexes():
day_event_id = ndx.data(Qt.UserRole + 1)
if day_event_id:
mainlog.debug("Removing event: {}".format(day_event_id))
event_ids.append(day_event_id)
# Remove them
if event_ids:
people_admin_service.remove_events(event_ids)
self.refresh_action()
def _make_days_off_menu_and_action_group(self):
# We use a action group to be able to use the data() of actions
# when action is tigerred
# Call this ONLY ONCE because there are signal/slot connections.
self.days_off_menu = QMenu(_("Day off"))
self.days_off_add_submenu = QMenu(_("Set day off"))
self.days_off_action_group = QActionGroup(self)
for det in DayEventType.symbols():
a_one = QAction(_("Set one day"), self.days_off_action_group)
a_one.setData((det.value, 1))
a_half = QAction(_("Set half day"), self.days_off_action_group)
a_half.setData((det.value, 0.5))
a_period = QAction(_("Set period"), self.days_off_action_group)
a_period.setData((det.value, 2))
self.days_off_action_group.addAction(a_one)
self.days_off_action_group.addAction(a_half)
self.days_off_action_group.addAction(a_period)
m = QMenu(_("Set time off for {}").format(det.description))
m.addAction(a_one)
m.addAction(a_half)
m.addAction(a_period)
self.days_off_add_submenu.addMenu(m)
self.days_off_action_group.triggered.connect(self._add_day_off)
self.day_off_remove_action = QAction(_("Remove day off"), self)
self.day_off_remove_action.triggered.connect(self._remove_day_off)
# Now we have the actions, we build the menu
self.days_off_menu.addMenu(self.days_off_add_submenu)
self.days_off_menu.addAction(self.day_off_remove_action)
@Slot(QPoint)
def popup_context_menu(self, position):
self.days_off_menu.exec_(QCursor.pos())
@Slot()
def select_all_slot(self):
m = self.table_view.model()
all = QItemSelection(m.index(0, 0),
m.index(m.rowCount() - 1,
m.columnCount() - 1))
self.table_view.selectionModel().select(all,
QItemSelectionModel.Select)
@Slot()
def copy_slot(self):
# Collect the rows indices
indices = self.table_view.selectedIndexes()
if not indices:
return
min_row = max_row = indices[0].row()
min_col = max_col = indices[0].column()
def min_max(minimum, v, maximum):
if v < minimum:
return v, maximum
elif v > maximum:
return minimum, v
else:
return minimum, maximum
for ndx in self.table_view.selectedIndexes():
min_row, max_row = min_max(min_row, ndx.row(), max_row)
min_col, max_col = min_max(min_col, ndx.column(), max_col)
mainlog.debug("Copy from {},{} to {},{}".format(
min_row, min_col, max_row, max_col))
day_max = calendar.monthrange(self.base_date.year,
self.base_date.month)[1]
s = ""
for r in range(min_row, max_row + 1):
d = []
for c in range(min_col, max_col + 1):
ndx = self._table_model.item(r, c)
if c == 0 or c > day_max:
d.append(ndx.data(Qt.DisplayRole) or "")
else:
t = ndx.data(Qt.UserRole + 1) # Day off
if t:
t = ndx.data(Qt.DisplayRole)
else:
hours = ndx.data(Qt.UserRole) # Activity hours
if hours is not None:
t = str(hours).replace('.', ',')
else:
t = ""
d.append(t)
s += "\t".join(d) + u"\n"
QApplication.clipboard().setText(s)
class TemplateSelectDialog(QDialog):
def refresh_templates_list(self):
documents = documents_service.all_templates()
self.model.removeRows(0, self.model.rowCount())
if documents:
for doc in sorted(list(documents), key=lambda d: d.filename):
self._add_one_document(doc.filename, doc.template_document_id,
doc.file_size, doc.description)
def __init__(self, parent=None):
super(TemplateSelectDialog, self).__init__(parent)
self.setWindowTitle(_("Select a template"))
self.template_id = []
self.model = QStandardItemModel()
self.view = QTableView()
self.view.setModel(self.model)
self.view.verticalHeader().setVisible(False)
self.view.horizontalHeader().setVisible(False)
self.view.setMinimumSize(500, 200)
self.view.setShowGrid(True)
self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.view.setSelectionBehavior(QAbstractItemView.SelectRows)
l = QVBoxLayout()
l.addWidget(QLabel(_("Please select one or more template.")))
self.view.doubleClicked.connect(self._doubleClicked)
l.addWidget(QLabel(u"<h3>{}</h3>".format(_("Documents Templates"))))
l.addWidget(self.view)
self.buttons = QDialogButtonBox()
self.buttons.addButton(QDialogButtonBox.StandardButton.Cancel)
self.buttons.addButton(QDialogButtonBox.Ok)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
l.addWidget(self.buttons)
self.setLayout(l)
def _add_one_document(self, file_name, doc_id, file_size, description):
""" Adds a document to the list
"""
# file_name is either an absolute path or just a file name
# If it is an absolute path, then the file is expected
# to exist locally (at it absolute path location of course).
# If not, then the file is expected to be a remote file
# and shall be downloaded before opening.
mainlog.debug(u"{} {} {} {}".format(file_name, doc_id, file_size,
description))
short_name = file_name
if os.path.isabs(file_name):
short_name = os.path.basename(file_name)
if not os.path.isfile(file_name):
raise Exception(u"The file {} doesn't exist".format(file_name))
items = [QStandardItem(short_name)]
items.append(QStandardItem(description))
self.model.appendRow(items)
self.model.setData(self.model.index(self.model.rowCount() - 1, 0),
doc_id, Qt.UserRole + 1)
self.view.horizontalHeader().setResizeMode(0, QHeaderView.Stretch)
self.view.horizontalHeader().setResizeMode(1, QHeaderView.Stretch)
self.view.resizeRowsToContents()
@Slot()
def accept(self):
selected_rows = self.view.selectionModel().selectedRows()
if selected_rows:
self.template_id = []
for row in selected_rows:
ndx_row = row.row()
self.template_id.append(
self.model.data(self.model.index(ndx_row, 0),
Qt.UserRole + 1))
else:
self.template_id = []
return super(TemplateSelectDialog, self).accept()
@Slot()
def reject(self):
return super(TemplateSelectDialog, self).reject()
@Slot(QModelIndex)
def _doubleClicked(self, ndx):
self.accept()
class PostViewWidget(HorsePanel):
def __init__(self, parent, order_overview_widget, find_order_slot):
global configuration
super(PostViewWidget, self).__init__(parent)
self.set_panel_title(_("Post overview"))
self.bold_font = QFont(self.font())
self.bold_font.setBold(True)
self.nb_cols = 8 # Number of columns in the operation definition table
self.order_overview_widget = order_overview_widget
self.button = QPushButton(_("Refresh"), self)
self.button.clicked.connect(self.refresh_action)
self.sort_by_deadline_button = QRadioButton(_("By deadline"), self)
self.sort_by_deadline_button.toggled.connect(self.sort_by_deadline)
self.sort_by_size_button = QRadioButton(_("By hours left to do"), self)
self.sort_by_size_button.toggled.connect(self.sort_by_size)
# hlayout = QHBoxLayout()
# hlayout.setObjectName("halyout")
# hlayout.setContentsMargins(0,0,0,0)
# hlayout.addWidget(self.sort_by_deadline_button)
# hlayout.addWidget(self.sort_by_size_button)
# hlayout.addWidget(self.button)
# hlayout.addStretch()
self.navbar = NavBar(self, [(self.sort_by_deadline_button, None),
(self.sort_by_size_button, None),
(self.button, None),
(_("Find"), find_order_slot)])
self.navbar.buttons[3].setObjectName("specialMenuButton")
self.vlayout = QVBoxLayout(self)
self.vlayout.setObjectName("Vlayout")
self.vlayout.addWidget(
TitleWidget(_("Posts Overview"), self, self.navbar))
self._table_model = QStandardItemModel(1, self.nb_cols, self)
self.table_view = QTableView(None)
self.table_view.setModel(self._table_model)
self.table_view.selectionModel().currentChanged.connect(
self.operation_selected)
self.table_view.verticalHeader().hide()
self.table_view.horizontalHeader().hide()
self.table_view.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.table_view.setSelectionBehavior(QAbstractItemView.SelectRows)
# This forces Qt to expand layout once I fill data in
# FIXME dirty but I really don't get why setting
# the mini width to something smaller (that happens at
# startup, on first refresh) doesn't work
self.table_view.setMinimumWidth(1)
self.table_view.setMaximumWidth(1)
self.post_view_scene = PostViewScene(self, order_overview_widget)
self.post_view_scene_view = QGraphicsView(self)
self.post_view_scene_view.setScene(self.post_view_scene)
self.post_view_scene_view.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.splitter = QSplitter(Qt.Horizontal)
self.splitter.addWidget(
SubFrame(_("Posts"), self.table_view, self.splitter))
self.splitter.addWidget(
SubFrame(_("Workload"), self.post_view_scene_view, self.splitter))
# self.splitter.setStretchFactor(0,1)
self.splitter.setStretchFactor(1, 1)
self.vlayout.addWidget(self.splitter)
# hlayout = QHBoxLayout()
# hlayout.addWidget(SubFrame(_("Posts"),self.table_view,self))
# hlayout.addWidget(SubFrame(_("Workload"),self.post_view_scene_view,self))
# hlayout.setStretch(1,1)
# self.vlayout.addLayout(hlayout)
self.vlayout.setStretch(0, 0)
self.vlayout.setStretch(1, 1)
self.setLayout(self.vlayout)
self.timer = QTimer(self)
self.timer.timeout.connect(self.slidePostsScene)
self.current_view_y = 0
def _data_load(self):
global dao
all_operations = dao.operation_dao.load_all_operations_ready_for_production(
)
operation_definitions = dao.operation_definition_dao.all_direct_frozen(
)
return operation_definitions, all_operations
def _reset_operation_definitions(self, operations):
self._table_model.setColumnCount(1)
self._table_model.setRowCount(len(operations))
# BUG This should be refreshed on reload() too
row = col = 0
first_active = None
for opdef in operations:
if opdef.operation_definition_id in self.post_view_scene.drawn_operations_data:
# currently total planned time
t = self.post_view_scene.drawn_operations_data[
opdef.operation_definition_id]
ndx = self._table_model.index(row, col)
if not first_active:
first_active = ndx
self._table_model.setData(
ndx, u"{} {}".format(opdef.description, t), Qt.DisplayRole)
# self._table_model.setData(ndx,self.bold_font,Qt.FontRole)
self._table_model.setData(self._table_model.index(row, col),
opdef.operation_definition_id,
Qt.UserRole)
row += 1
else:
pass
# self._table_model.setData(self._table_model.index(row,col),opdef.description,Qt.DisplayRole)
# = col + 1
# if col == self.nb_cols:
# col = 0
# row += 1
self._table_model.setRowCount(row)
# self.table_view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
# self.vlayout.setStretch(0,0)
# self.vlayout.setStretch(1,10)
# self.vlayout.setStretch(2,10000)
# height = 0
# for c in range(self.table_view.model().rowCount()):
# height += self.table_view.rowHeight(c) + 1 # +1 for cell border
# self.table_view.setMinimumHeight(height)
# self.table_view.setMaximumHeight(height)
for i in range(self.nb_cols):
self.table_view.resizeColumnToContents(i)
self.table_view.setMaximumWidth(self.table_view.columnWidth(0))
self.table_view.setMinimumWidth(self.table_view.columnWidth(0))
self.table_view.setSizePolicy(QSizePolicy.Maximum,
QSizePolicy.Preferred)
self.table_view.update()
self.splitter.update()
return first_active
def slide_to_operation(self, opdef_id):
if opdef_id in self.post_view_scene.posts_offsets:
self.slide_target_opdef_id = opdef_id
# mainlog.debug("Target y = {}".format(self.post_view_scene.posts_offsets[self.slide_target_opdef]))
self.timer.start(20)
@Slot()
def slidePostsScene(self):
if self.slide_target_opdef_id is None:
return
# self.post_view_scene_view
self.post_view_scene.set_cursor_on(
self.slide_target_opdef_id
) # This done here also aviod some screen trashing
v = self.post_view_scene_view.verticalScrollBar().value()
# mainlog.debug( "slidePostsScene : {}".format(v))
r = self.post_view_scene.posts_offsets[self.slide_target_opdef_id]
target_y = r.y() + r.height() / 2
delta = (target_y - self.current_view_y) * 0.4
self.current_view_y = self.current_view_y + delta
self.post_view_scene_view.centerOn(0, self.current_view_y)
# mainlog.debug( "slidePostsScene : {} / {}".format(target_y, self.current_view_y))
if self.post_view_scene_view.verticalScrollBar().value() == v:
# Close enough => stop moving
# FIXME not correct because we must stop when the view stops moving, not when the goal we set for centerOn is reached
self.timer.stop()
@Slot(QModelIndex, QModelIndex)
def operation_selected(self, ndx_cur, ndx_old):
if ndx_cur.isValid():
opdef = self._table_model.data(ndx_cur, Qt.UserRole)
if opdef:
self.slide_to_operation(
self._table_model.data(ndx_cur, Qt.UserRole))
@Slot()
def refresh_action(self):
# FIXME reload operations as well
operation_definitions, all_operations = self._data_load()
# mainlog.debug("reload")
if self.sort_by_deadline_button.isChecked():
self.post_view_scene.reload(self, operation_definitions,
all_operations, 1)
elif self.sort_by_size_button.isChecked():
self.post_view_scene.reload(self, operation_definitions,
all_operations, 2)
else:
self.post_view_scene.reload(self, operation_definitions,
all_operations, 0)
# mainlog.debug("reset")
first_active = self._reset_operation_definitions(operation_definitions)
# self.table_view.selectionModel().currentChanged.connect(self.operation_selected)
if first_active:
self.table_view.setCurrentIndex(first_active)
# mainlog.debug("done reset")
@Slot(bool)
def sort_by_deadline(self, checked):
if checked:
self.refresh_action()
@Slot(bool)
def sort_by_size(self, checked):
if checked:
self.refresh_action()
order_part_double_clicked = Signal(int)
# Callback that will be called by HooverBar
def set_on_order_part(self, order_part_id):
self.order_part_double_clicked.emit(order_part_id)
