def populateTree(self, projects):
"""populates tree with user projects
"""
logger.debug('TaskTreeModel.populateTree() is started')
self.setColumnCount(4)
self.setHorizontalHeaderLabels(
['Name', 'Type', 'Resources', 'Dependencies'])
for project in projects:
project_item = TaskItem(0, 4, task=project)
project_item.parent = None
project_item.setColumnCount(4)
# Set Font
my_font = project_item.font()
my_font.setBold(True)
project_item.setFont(my_font)
# color with task status
from anima import defaults
project_item.setData(
QtGui.QColor(
*defaults.status_colors_by_id.get(project.status_id)),
QtCore.Qt.BackgroundRole)
# use black text
project_item.setForeground(QtGui.QBrush(QtGui.QColor(0, 0, 0)))
self.appendRow(project_item)
logger.debug('TaskTreeModel.populateTree() is finished')
def setup_ui(self):
"""create the UI widgets
"""
self.vertical_layout = QtWidgets.QVBoxLayout(self)
self.setLayout(self.vertical_layout)
# the widget should consist of a QGraphic
self.thumbnail_graphics_view = QtWidgets.QGraphicsView(self)
# set size policy
size_policy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed,
QtWidgets.QSizePolicy.Fixed)
size_policy.setHorizontalStretch(0)
size_policy.setVerticalStretch(0)
size_policy.setHeightForWidth(
self.thumbnail_graphics_view.sizePolicy().hasHeightForWidth())
self.thumbnail_graphics_view.setSizePolicy(size_policy)
# set size
default_size = QtCore.QSize(*self.default_thumbnail_size)
self.thumbnail_graphics_view.setMinimumSize(default_size)
self.thumbnail_graphics_view.setMaximumSize(default_size)
self.thumbnail_graphics_view.setAutoFillBackground(False)
self.thumbnail_graphics_view.setVerticalScrollBarPolicy(
QtCore.Qt.ScrollBarAlwaysOff)
self.thumbnail_graphics_view.setHorizontalScrollBarPolicy(
QtCore.Qt.ScrollBarAlwaysOff)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
self.thumbnail_graphics_view.setBackgroundBrush(brush)
self.thumbnail_graphics_view.setInteractive(False)
self.thumbnail_graphics_view.setRenderHints(
QtGui.QPainter.Antialiasing
| QtGui.QPainter.HighQualityAntialiasing
| QtGui.QPainter.SmoothPixmapTransform
| QtGui.QPainter.TextAntialiasing)
self.vertical_layout.addWidget(self.thumbnail_graphics_view)
self.upload_thumbnail_button = QtWidgets.QPushButton(self)
self.upload_thumbnail_button.setText("Upload...")
self.upload_thumbnail_button.setGeometry(
self.thumbnail_graphics_view.geometry())
self.upload_thumbnail_button.setVisible(True)
self.vertical_layout.addWidget(self.upload_thumbnail_button)
# create signals
# QtCore.QObject.connect(
# self.thumbnail_graphics_view,
# QtCore.SIGNAL("clicked()"),
# self.thumbnail_graphics_view_clicked
# )
QtCore.QObject.connect(self.upload_thumbnail_button,
QtCore.SIGNAL("clicked()"),
self.upload_thumbnail_button_clicked)
def set_published_font(item):
"""sets the font for the given item
:param item: the a QTableWidgetItem
"""
my_font = item.font()
my_font.setBold(True)
item.setFont(my_font)
foreground = item.foreground()
foreground.setColor(QtGui.QColor(0, 192, 0))
item.setForeground(foreground)
def paintEvent(self, event):
"""Overridden paint event
:param event: QPaintEvent instance
:return:
"""
super(ValidatedLineEdit, self).paintEvent(event)
if self.icon is not None:
painter = QtGui.QPainter(self)
pixmap = self.icon.pixmap(self.height() - 6, self.height() - 6)
x = self.width() - self.height() + 4
painter.drawPixmap(x, 3, pixmap)
painter.setPen(QtGui.QColor("lightgrey"))
painter.drawLine(x - 2, 3, x - 2, self.height() - 4)
def setup_ui(self):
"""create the UI widgets
"""
self.vertical_layout = QtWidgets.QVBoxLayout(self)
from anima.ui.lib import QtCore, QtGui
# the widget should consist of a QGraphic
self.thumbnail_graphics_view = QtWidgets.QGraphicsView(self)
# set size policy
size_policy = QtWidgets.QSizePolicy(
QtWidgets.QSizePolicy.Fixed,
QtWidgets.QSizePolicy.Fixed
)
size_policy.setHorizontalStretch(0)
size_policy.setVerticalStretch(0)
size_policy.setHeightForWidth(
self.thumbnail_graphics_view.sizePolicy().hasHeightForWidth())
self.thumbnail_graphics_view.setSizePolicy(size_policy)
# set size
default_size = QtCore.QSize(
self.default_thumbnail_size,
self.default_thumbnail_size
)
self.thumbnail_graphics_view.setMinimumSize(default_size)
self.thumbnail_graphics_view.setMaximumSize(default_size)
self.thumbnail_graphics_view.setAutoFillBackground(False)
self.thumbnail_graphics_view.setVerticalScrollBarPolicy(
QtCore.Qt.ScrollBarAlwaysOff
)
self.thumbnail_graphics_view.setHorizontalScrollBarPolicy(
QtCore.Qt.ScrollBarAlwaysOff
)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
self.thumbnail_graphics_view.setBackgroundBrush(brush)
self.thumbnail_graphics_view.setInteractive(False)
self.thumbnail_graphics_view.setRenderHints(
QtGui.QPainter.Antialiasing |
QtGui.QPainter.HighQualityAntialiasing |
QtGui.QPainter.SmoothPixmapTransform |
QtGui.QPainter.TextAntialiasing
)
self.vertical_layout.addWidget(self.thumbnail_graphics_view)
def generate_version_row(cls, parent, pseudo_model, version):
"""Generates a new version row
:return:
"""
# column 0
version_item = VersionItem(0, 0)
version_item.parent = parent
version_item.pseudo_model = pseudo_model
version_item.version = version
version_item.setEditable(False)
reference_resolution = pseudo_model.reference_resolution
if version in reference_resolution['update']:
action = 'update'
font_color = QtGui.QColor(192, 128, 0)
if version in reference_resolution['root']:
version_item.setCheckable(True)
version_item.setCheckState(QtCore.Qt.Checked)
elif version in reference_resolution['create']:
action = 'create'
font_color = QtGui.QColor(192, 0, 0)
if version in reference_resolution['root']:
version_item.setCheckable(True)
version_item.setCheckState(QtCore.Qt.Checked)
else:
font_color = QtGui.QColor(0, 192, 0)
action = ''
version_item.action = action
set_item_color(version_item, font_color)
# thumbnail
thumbnail_item = QtGui.QStandardItem()
thumbnail_item.setEditable(False)
# thumbnail_item.setText('no thumbnail')
thumbnail_item.version = version
thumbnail_item.action = action
set_item_color(thumbnail_item, font_color)
# Nice Name
nice_name_item = QtGui.QStandardItem()
nice_name_item.toolTip()
nice_name_item.setText('%s_v%s' %
(version.nice_name,
('%s' % version.version_number).zfill(3)))
nice_name_item.setEditable(False)
nice_name_item.version = version
nice_name_item.action = action
set_item_color(nice_name_item, font_color)
# Take
take_item = QtGui.QStandardItem()
take_item.setEditable(False)
take_item.setText(version.take_name)
take_item.version = version
take_item.action = action
set_item_color(take_item, font_color)
# Current
current_version_item = QtGui.QStandardItem()
current_version_item.setText('%s' % version.version_number)
current_version_item.setEditable(False)
current_version_item.version = version
current_version_item.action = action
set_item_color(current_version_item, font_color)
# Latest
latest_published_version = version.latest_published_version
latest_published_version_item = QtGui.QStandardItem()
latest_published_version_item.version = version
latest_published_version_item.action = action
latest_published_version_item.setEditable(False)
latest_published_version_text = 'No Published Version'
if latest_published_version:
latest_published_version_text = '%s' % \
latest_published_version.version_number
latest_published_version_item.setText(latest_published_version_text)
set_item_color(latest_published_version_item, font_color)
# Action
action_item = QtGui.QStandardItem()
action_item.setEditable(False)
action_item.setText(action)
action_item.version = version
action_item.action = action
set_item_color(action_item, font_color)
# Updated By
updated_by_item = QtGui.QStandardItem()
updated_by_item.setEditable(False)
updated_by_text = ''
if latest_published_version and latest_published_version.updated_by:
updated_by_text = latest_published_version.updated_by.name
updated_by_item.setText(updated_by_text)
updated_by_item.version = version
updated_by_item.action = action
set_item_color(updated_by_item, font_color)
# Description
description_item = QtGui.QStandardItem()
if latest_published_version:
description_item.setText(latest_published_version.description)
description_item.setEditable(False)
description_item.version = version
description_item.action = action
set_item_color(description_item, font_color)
# # Path
# path_item = QtGui.QStandardItem()
# if latest_published_version:
# path_item.setText(version.absolute_full_path)
# path_item.setEditable(True)
# set_item_color(path_item, font_color)
return [
version_item, thumbnail_item, nice_name_item, take_item,
current_version_item, latest_published_version_item, action_item,
updated_by_item, description_item
]
def fetchMore(self):
logger.debug('TaskItem.fetchMore() is started for item: %s' %
self.text())
if self.canFetchMore():
from sqlalchemy.orm import aliased
from sqlalchemy.dialects.postgresql import array_agg
from stalker import Task, User
from stalker.models.task import Task_Resources
from stalker.db.session import DBSession
inner_tasks = aliased(Task)
subquery = DBSession.query(Task.id) \
.filter(Task.id == inner_tasks.parent_id)
query = DBSession.query(
Task.id,
Task.name,
Task.entity_type,
Task.status_id,
subquery.exists().label('has_children'),
array_agg(User.name).label('resources')
) \
.outerjoin(Task_Resources, Task.__table__.c.id == Task_Resources.c.task_id) \
.outerjoin(User, Task_Resources.c.resource_id == User.id) \
.group_by(
Task.id,
Task.name,
Task.entity_type,
Task.status_id,
subquery.exists().label('has_children')
)
if self.task.entity_type != 'Project':
# query child tasks
query = query.filter(Task.parent_id == self.task.id)
else:
# query only root tasks
query = query.filter(Task.project_id == self.task.id)\
.filter(Task.parent_id==None)
tasks = query.order_by(Task.name).all()
# # model = self.model() # This will cause a SEGFAULT
# # TODO: update it later on
# start = time.time()
from anima import defaults
task_items = []
for task in tasks:
task_item = TaskItem(0, 4, task=task)
task_item.parent = self
# color with task status
task_item.setData(
QtGui.QColor(
*defaults.status_colors_by_id[task.status_id]),
QtCore.Qt.BackgroundRole)
# use black text
task_item.setForeground(QtGui.QBrush(QtGui.QColor(0, 0, 0)))
task_items.append(task_item)
if task_items:
# self.appendRows(task_items)
for task_item in task_items:
# TODO: Create a custom QStandardItem for each data type in different columns
entity_type_item = QtGui.QStandardItem()
entity_type_item.setData(task_item.task.entity_type,
QtCore.Qt.DisplayRole)
resources_item = QtGui.QStandardItem()
if task_item.task.resources != [None]:
resources_item.setData(
', '.join(map(str, task_item.task.resources)),
QtCore.Qt.DisplayRole)
self.appendRow(
[task_item, entity_type_item, resources_item])
self.fetched_all = True
logger.debug('TaskItem.fetchMore() is finished for item: %s' %
self.text())
def fill_calendar_with_time_logs(self):
"""fill the calendar with daily time log info
"""
resource_id = self.get_current_resource_id()
# do not update if the calendar is showing the same user
if self.calendar_widget.resource_id == resource_id or resource_id == -1:
return
tool_tip_text_format = u'{start:%H:%M} - {end:%H:%M} | {task_name}'
# import time
# start = time.time()
# get all the TimeLogs grouped daily
sql = """-- TOP DOWN SEARCH --
select
"TimeLogs".start::date as date,
array_agg(task_rec_data.full_path) as task_name,
array_agg("TimeLogs".start) as start,
array_agg("TimeLogs".end) as end,
sum(extract(epoch from ("TimeLogs".end - "TimeLogs".start)))
from "TimeLogs"
join (
with recursive recursive_task(id, parent_id, path_names) as (
select
task.id,
task.project_id,
-- task.project_id::text as path,
("Projects".code || '') as path_names
from "Tasks" as task
join "Projects" on task.project_id = "Projects".id
where task.parent_id is NULL
union all
select
task.id,
task.parent_id,
-- (parent.path || '|' || task.parent_id:: text) as path,
(parent.path_names || ' | ' || "Parent_SimpleEntities".name) as path_names
from "Tasks" as task
inner join recursive_task as parent on task.parent_id = parent.id
inner join "SimpleEntities" as "Parent_SimpleEntities" on parent.id = "Parent_SimpleEntities".id
) select
recursive_task.id,
"SimpleEntities".name || ' (' || recursive_task.path_names || ')' as full_path
from recursive_task
join "SimpleEntities" on recursive_task.id = "SimpleEntities".id
) as task_rec_data on "TimeLogs".task_id = task_rec_data.id
-- getting all the data is as fast as getting one, so get all the TimeLogs of this user
where "TimeLogs".resource_id = :resource_id
group by cast("TimeLogs".start as date)
order by cast("TimeLogs".start as date)
"""
from sqlalchemy import text
from stalker.db.session import DBSession
result = DBSession.connection().execute(
text(sql),
resource_id=resource_id
).fetchall()
# end = time.time()
# print('getting data from sql: %0.3f sec' % (end - start))
from anima.utils import utc_to_local
time_shifter = utc_to_local
import stalker
# TODO: Remove this in a later version
from distutils.version import LooseVersion
if LooseVersion(stalker.__version__) >= LooseVersion('0.2.18'):
def time_shifter(x):
return x
for r in result:
calendar_day = r[0]
year = calendar_day.year
month = calendar_day.month
day = calendar_day.day
daily_logged_seconds = r[4]
daily_logged_hours = daily_logged_seconds // 3600
daily_logged_minutes = \
(daily_logged_seconds - daily_logged_hours * 3600) // 60
tool_tip_text_data = [
u'Total: %i h %i min logged' %
(daily_logged_hours, daily_logged_minutes)
if daily_logged_hours
else u'Total: %i min logged' % daily_logged_minutes
]
for task_name, start, end in sorted(
zip(r[1], r[2], r[3]), key=lambda x: x[1]):
time_log_tool_tip_text = tool_tip_text_format.format(
start=time_shifter(start),
end=time_shifter(end),
task_name=task_name
)
tool_tip_text_data.append(time_log_tool_tip_text)
merged_tool_tip = u'\n'.join(tool_tip_text_data)
date_format = QtGui.QTextCharFormat()
bg_brush = QtGui.QBrush()
bg_brush.setColor(
QtGui.QColor(0, 255.0 / 86400.0 * daily_logged_seconds, 0)
)
date_format.setBackground(bg_brush)
date_format.setToolTip(merged_tool_tip)
date = QtCore.QDate(year, month, day)
self.calendar_widget.setDateTextFormat(date, date_format)
def update_content(self, versions):
"""updates the content with the given versions data
"""
import os
import datetime
logger.debug('VersionsTableWidget.update_content() is started')
self.clear()
self.versions = versions
self.setRowCount(len(versions))
def set_published_font(item):
"""sets the font for the given item
:param item: the a QTableWidgetItem
"""
my_font = item.font()
my_font.setBold(True)
item.setFont(my_font)
foreground = item.foreground()
foreground.setColor(QtGui.QColor(0, 192, 0))
item.setForeground(foreground)
# update the previous versions list
from anima import defaults
for i, version in enumerate(versions):
is_published = version.is_published
absolute_full_path = os.path.normpath(
os.path.expandvars(version.full_path)).replace('\\', '/')
version_file_exists = os.path.exists(absolute_full_path)
c = 0
# ------------------------------------
# version_number
item = QtWidgets.QTableWidgetItem(str(version.version_number))
# align to center and vertical center
item.setTextAlignment(0x0004 | 0x0080)
if is_published:
set_published_font(item)
if not version_file_exists:
item.setBackground(QtGui.QColor(64, 0, 0))
self.setItem(i, c, item)
c += 1
# ------------------------------------
# ------------------------------------
# created_with
item = QtWidgets.QTableWidgetItem()
if version.created_with:
from anima.ui import utils as ui_utils
item.setIcon(ui_utils.get_icon(version.created_with.lower()))
if is_published:
set_published_font(item)
if not version_file_exists:
item.setBackground(QtGui.QColor(64, 0, 0))
self.setItem(i, c, item)
c += 1
# ------------------------------------
# ------------------------------------
# user.name
created_by = ''
if version.created_by_id:
created_by = defaults.user_names_lut[version.created_by_id]
item = QtWidgets.QTableWidgetItem(created_by)
# align to left and vertical center
item.setTextAlignment(0x0001 | 0x0080)
if is_published:
set_published_font(item)
if not version_file_exists:
item.setBackground(QtGui.QColor(64, 0, 0))
self.setItem(i, c, item)
c += 1
# ------------------------------------
# ------------------------------------
# user.name
updated_by = ''
if version.updated_by_id:
updated_by = defaults.user_names_lut[version.updated_by_id]
item = QtWidgets.QTableWidgetItem(updated_by)
# align to left and vertical center
item.setTextAlignment(0x0001 | 0x0080)
if is_published:
set_published_font(item)
if not version_file_exists:
item.setBackground(QtGui.QColor(64, 0, 0))
self.setItem(i, c, item)
c += 1
# ------------------------------------
# ------------------------------------
# file size
# get the file size
# file_size_format = "%.2f MB"
file_size = -1
if version_file_exists:
file_size = float(
os.path.getsize(absolute_full_path)) / 1048576
from anima import defaults
item = QtWidgets.QTableWidgetItem(defaults.file_size_format %
file_size)
# align to left and vertical center
item.setTextAlignment(0x0001 | 0x0080)
if is_published:
set_published_font(item)
if not version_file_exists:
item.setBackground(QtGui.QColor(64, 0, 0))
self.setItem(i, c, item)
c += 1
# ------------------------------------
# ------------------------------------
# date
# get the file date
file_date = datetime.datetime.today()
if version_file_exists:
file_date = datetime.datetime.fromtimestamp(
os.path.getmtime(absolute_full_path))
item = QtWidgets.QTableWidgetItem(
file_date.strftime(defaults.date_time_format))
# align to left and vertical center
item.setTextAlignment(0x0001 | 0x0080)
if is_published:
set_published_font(item)
if not version_file_exists:
item.setBackground(QtGui.QColor(64, 0, 0))
self.setItem(i, c, item)
c += 1
# ------------------------------------
# ------------------------------------
# description
item = QtWidgets.QTableWidgetItem(version.description)
# align to left and vertical center
item.setTextAlignment(0x0001 | 0x0080)
if is_published:
set_published_font(item)
if not version_file_exists:
item.setBackground(QtGui.QColor(64, 0, 0))
self.setItem(i, c, item)
c += 1
# ------------------------------------
# resize the first column
self.resizeRowsToContents()
self.resizeColumnsToContents()
self.resizeRowsToContents()
logger.debug('VersionsTableWidget.update_content() is finished')
def fetchMore(self):
logger.debug(
'TaskItem.fetchMore() is started for item: %s' % self.text()
)
if self.canFetchMore():
tasks = []
if isinstance(self.task, Task):
tasks = self.task.children
elif isinstance(self.task, Project):
tasks = self.task.root_tasks
# model = self.model() # This will cause a SEGFAULT
if self.user_tasks_only:
user_tasks_and_parents = []
# need to filter tasks which do not belong to user
for task in tasks:
for user_task in self.user.tasks:
if task in user_task.parents or \
task is user_task or \
task in self.user.projects:
user_tasks_and_parents.append(task)
break
tasks = user_tasks_and_parents
tasks = sorted(tasks, key=lambda x: x.name)
for task in tasks:
task_item = TaskItem(0, 3)
task_item.parent = self
task_item.task = task
task_item.user = self.user
task_item.user_tasks_only = self.user_tasks_only
# set the font
# name_item = QtGui.QStandardItem(task.name)
# entity_type_item = QtGui.QStandardItem(task.entity_type)
# task_item.setItem(0, 0, name_item)
# task_item.setItem(0, 1, entity_type_item)
task_item.setText(task.name)
make_bold = False
if isinstance(task, Task):
if task.is_container:
make_bold = True
elif isinstance(task, Project):
make_bold = True
if make_bold:
my_font = task_item.font()
my_font.setBold(True)
task_item.setFont(my_font)
# color with task status
task_item.setData(
QtGui.QColor(
*status_colors[task_item.task.status.code.lower()]
),
QtCore.Qt.BackgroundRole
)
# use black text
task_item.setForeground(
QtGui.QBrush(QtGui.QColor(0, 0, 0))
)
self.appendRow(task_item)
self.fetched_all = True
logger.debug(
'TaskItem.fetchMore() is finished for item: %s' % self.text()
)
def fetchMore(self):
logger.debug(
'TaskItem.fetchMore() is started for item: %s' % self.text()
)
if self.canFetchMore():
from sqlalchemy import alias
from stalker import Task
from stalker.db.session import DBSession
inner_tasks = alias(Task.__table__)
subquery = DBSession.query(Task.id)\
.filter(Task.id == inner_tasks.c.parent_id)
query = DBSession.query(
Task.id,
Task.name,
Task.entity_type,
Task.status_id,
subquery.exists().label('has_children')
)
if self.task.entity_type != 'Project':
# query child tasks
query = query.filter(Task.parent_id == self.task.id)
else:
# query only root tasks
query = query.filter(Task.project_id == self.task.id)\
.filter(Task.parent_id==None)
tasks = query.order_by(Task.name).all()
# # model = self.model() # This will cause a SEGFAULT
# # TODO: update it later on
# start = time.time()
from anima import defaults
task_items = []
for task in tasks:
task_item = TaskItem(0, 3, entity=task)
task_item.parent = self
# color with task status
task_item.setData(
QtGui.QColor(
*defaults.status_colors_by_id[task.status_id]
),
QtCore.Qt.BackgroundRole
)
# use black text
task_item.setForeground(
QtGui.QBrush(QtGui.QColor(0, 0, 0))
)
task_items.append(task_item)
if task_items:
self.appendRows(task_items)
self.fetched_all = True
logger.debug(
'TaskItem.fetchMore() is finished for item: %s' % self.text()
)
def fetchMore(self):
logger.debug(
'TaskItem.fetchMore() is started for item: %s' % self.text()
)
if self.canFetchMore():
tasks = []
if self.task_name is None:
self.task_name, self.task_entity_type = \
db.DBSession \
.query(SimpleEntity.name, SimpleEntity.entity_type) \
.filter(SimpleEntity.id == self.task_id) \
.first()
if self.task_children_data is None:
if self.task_entity_type in self.task_entity_types:
self.task_children_data = db.DBSession \
.query(Task.id, Task.name, Task.entity_type, Task.status_id) \
.filter(Task.parent_id == self.task_id) \
.order_by(Task.name) \
.all()
elif self.task_entity_type == 'Project':
self.task_children_data = db.DBSession\
.query(Task.id, Task.name, Task.entity_type, Task.status_id) \
.filter(Task.parent_id == None) \
.filter(Task.project_id == self.task_id) \
.order_by(Task.name) \
.all()
tasks = self.task_children_data
# # model = self.model() # This will cause a SEGFAULT
# # TODO: update it later on
# if self.user_tasks_only:
# user_tasks_and_parents = []
# # need to filter tasks which do not belong to user
# for task in tasks:
# for user_task in self.user.tasks:
# if task in user_task.parents or \
# task is user_task or \
# task in self.user.projects:
# user_tasks_and_parents.append(task)
# break
#
# tasks = user_tasks_and_parents
# # tasks = sorted(tasks, key=lambda x: x.name)
# start = time.time()
task_items = []
for task in tasks:
task_item = TaskItem(0, 3)
task_item.parent = self
task_item.task_id = task[0]
task_item.user_id = self.user_id
task_item.user_tasks_only = self.user_tasks_only
# set the font
# name_item = QtGui.QStandardItem(task.name)
# entity_type_item = QtGui.QStandardItem(task.entity_type)
# task_item.setItem(0, 0, name_item)
# task_item.setItem(0, 1, entity_type_item)
task_item.setText(task[1])
# make_bold = False
# if task_item.canFetchMore():
# make_bold = True
# if task[2] in self.task_entity_types:
# children_count = \
# db.DBSession.query(Task.id)\
# .filter(Task.parent_id == task[0])\
# .count()
# if children_count:
# make_bold = True
# elif task[2] == 'Project':
# make_bold = True
# if make_bold:
# my_font = task_item.font()
# my_font.setBold(True)
# task_item.setFont(my_font)
# color with task status
task_item.setData(
QtGui.QColor(
*status_colors_by_id[task[3]]
),
QtCore.Qt.BackgroundRole
)
# use black text
task_item.setForeground(
QtGui.QBrush(QtGui.QColor(0, 0, 0))
)
task_items.append(task_item)
if task_items:
self.appendRows(task_items)
self.fetched_all = True
logger.debug(
'TaskItem.fetchMore() is finished for item: %s' % self.text()
)