def data(self, index, role):
"""Handles how the the items are displayed in the
table using roles."""
if index.isValid():
# data is the text displayed for every index in the table
data = self.data[index.row()][index.column()]
if role == Qt.ItemDataRole.DisplayRole:
return data
# Demonstrates how to set bold text for a specific column
if role == Qt.ItemDataRole.FontRole and index.column() == 0:
bold_font = QFont()
bold_font.setBold(True)
return bold_font
# Demonstrates how to set the background color in order to highlight
# specific cells that contain desired values
if role == Qt.ItemDataRole.BackgroundRole and "Brown Trout" in data:
blue_bg = QBrush(QColor("#6EEEF8"))
return blue_bg
def load(self, path: str, is_first_call: bool = True) -> None:
if path == self._path:
return
theme_full_path = os.path.join(path, "theme.json")
Logger.log(
"d", "Loading theme file: {theme_full_path}".format(
theme_full_path=theme_full_path))
try:
with open(theme_full_path, encoding="utf-8") as f:
data = json.load(f)
except EnvironmentError as e:
Logger.error(
"Unable to load theme file at {theme_full_path}: {err}".format(
theme_full_path=theme_full_path, err=e))
return
except UnicodeDecodeError:
Logger.error(
"Theme file at {theme_full_path} is corrupt (invalid UTF-8 bytes)."
.format(theme_full_path=theme_full_path))
return
except json.JSONDecodeError:
Logger.error(
"Theme file at {theme_full_path} is corrupt (invalid JSON syntax)."
.format(theme_full_path=theme_full_path))
return
# Iteratively load inherited themes
try:
theme_id = data["metadata"]["inherits"]
self.load(Resources.getPath(Resources.Themes, theme_id),
is_first_call=False)
except FileNotFoundError:
Logger.log("e", "Could not find inherited theme %s", theme_id)
except KeyError:
pass # No metadata or no inherits keyword in the theme.json file
if "colors" in data:
for name, value in data["colors"].items():
if not is_first_call and isinstance(value, str):
# Keep parent theme string colors as strings and parse later
self._colors[name] = value
continue
if isinstance(value, str) and is_first_call:
# value is reference to base_colors color name
try:
color = data["base_colors"][value]
except IndexError:
Logger.log(
"w",
"Colour {value} could not be found in base_colors".
format(value=value))
continue
else:
color = value
try:
c = QColor(color[0], color[1], color[2], color[3])
except IndexError: # Color doesn't have enough components.
Logger.log(
"w",
"Colour {name} doesn't have enough components. Need to have 4, but had {num_components}."
.format(name=name, num_components=len(color)))
continue # Skip this one then.
self._colors[name] = c
if "base_colors" in data:
for name, color in data["base_colors"].items():
try:
c = QColor(color[0], color[1], color[2], color[3])
except IndexError: # Color doesn't have enough components.
Logger.log(
"w",
"Colour {name} doesn't have enough components. Need to have 4, but had {num_components}."
.format(name=name, num_components=len(color)))
continue # Skip this one then.
self._colors[name] = c
if is_first_call and self._colors:
#Convert all string value colors to their referenced color
for name, color in self._colors.items():
if isinstance(color, str):
try:
c = self._colors[color]
self._colors[name] = c
except:
Logger.log(
"w",
"Colour {name} {color} does".format(name=name,
color=color))
fonts_dir = os.path.join(path, "fonts")
if os.path.isdir(fonts_dir):
for root, dirnames, filenames in os.walk(fonts_dir):
for filename in filenames:
if filename.lower().endswith(".ttf"):
QFontDatabase.addApplicationFont(
os.path.join(root, filename))
if "fonts" in data:
system_font_size = QCoreApplication.instance().font().pointSize()
for name, font in data["fonts"].items():
q_font = QFont()
q_font.setFamily(
font.get("family",
QCoreApplication.instance().font().family()))
if font.get("bold"):
q_font.setBold(font.get("bold", False))
else:
q_font.setWeight(font.get("weight", 500))
q_font.setLetterSpacing(QFont.SpacingType.AbsoluteSpacing,
font.get("letterSpacing", 0))
q_font.setItalic(font.get("italic", False))
q_font.setPointSize(int(
font.get("size", 1) * system_font_size))
q_font.setCapitalization(QFont.Capitalization.AllUppercase
if font.get("capitalize", False) else
QFont.Capitalization.MixedCase)
self._fonts[name] = q_font
if "sizes" in data:
for name, size in data["sizes"].items():
s = QSizeF()
s.setWidth(round(size[0] * self._em_width))
s.setHeight(round(size[1] * self._em_height))
self._sizes[name] = s
iconsdir = os.path.join(path, "icons")
if os.path.isdir(iconsdir):
try:
for base_path, _, icons in os.walk(iconsdir):
detail_level = base_path.split(os.sep)[-1]
if detail_level not in self._icons:
self._icons[detail_level] = {}
for icon in icons:
name = os.path.splitext(icon)[0]
self._icons[detail_level][name] = QUrl.fromLocalFile(
os.path.join(base_path, icon))
except EnvironmentError as err: # Exception when calling os.walk, e.g. no access rights.
Logger.error(
f"Can't access icons of theme ({iconsdir}): {err}")
# Won't get any icons then. Images will show as black squares.
deprecated_icons_file = os.path.join(iconsdir,
"deprecated_icons.json")
if os.path.isfile(deprecated_icons_file):
try:
with open(deprecated_icons_file, encoding="utf-8") as f:
data = json.load(f)
for icon in data:
self._deprecated_icons[icon] = data[icon]
except (UnicodeDecodeError, json.decoder.JSONDecodeError,
EnvironmentError):
Logger.logException(
"w", "Could not parse deprecated icons list %s",
deprecated_icons_file)
imagesdir = os.path.join(path, "images")
if os.path.isdir(imagesdir):
try:
for image in os.listdir(imagesdir):
name = os.path.splitext(image)[0]
self._images[name] = QUrl.fromLocalFile(
os.path.join(imagesdir, image))
except EnvironmentError as err: # Exception when calling os.listdir, e.g. no access rights.
Logger.error(
f"Can't access image of theme ({imagesdir}): {err}")
# Won't get any images then. They will show as black squares.
Logger.log("d", "Loaded theme %s", path)
Logger.info(f"System's em size is {self._em_height}px.")
self._path = path
# only emit the theme loaded signal once after all the themes in the inheritance chain have been loaded
if is_first_call:
self.themeLoaded.emit()
n = 8 # even integer
CELLRATIO = 3 / 5
FONTSIZE = 10
BLUE = QColor("#031591")
YELLOW = QColor("#ffcc00")
RED = QColor("#ff0000")
BLACK = QColor("#000000")
GREY = QColor("#505050")
WHITE = QColor("#ffffff")
GREEN = QColor("#33cc33")
BOARDSIZE = (6, 6)
CATFONT = QFont()
CATFONT.setBold(True)
CATFONT.setPixelSize(24)
CATPEN = QPen(WHITE)
MONFONT = QFont(CATFONT)
MONFONT.setPixelSize(50)
MONPEN = QPen(YELLOW)
TEXTPADDING = 20
QUFONT = QFont()
QUFONT.setPixelSize(70)
QUMARGIN = 50
NAMEHEIGHT = 50
NAMEFONT = QFont()
NAMEFONT.setPixelSize(20)
def generate_itemGroup(self, xs, ys, label, type):
gItemGroup = QGraphicsItemGroup()
pointBbx = QRectF()
pointBbx.setSize(QSizeF(self.gView.labelSize, self.gView.labelSize))
textLabel = QGraphicsTextItem(label)
if len(xs) == 1:
pointBbx.moveCenter(QPointF(xs[0], ys[0]))
textLabel.setPos(xs[0] - (textLabel.boundingRect().width() / 2),
ys[0] - (textLabel.boundingRect().height() / 2))
pointShape = QGraphicsEllipseItem(pointBbx)
shapeColor = Qt.GlobalColor.white
textColor = Qt.GlobalColor.black
tooltip = 'P{}:{}'
elif len(xs) == 2:
pointBbx.moveCenter(QPointF(xs[1], ys[1]))
textLabel.setPos(xs[1] - (textLabel.boundingRect().width() / 2),
ys[1] - (textLabel.boundingRect().height() / 2))
r, g, b = np.random.choice(range(256), size=3)
line_item = QGraphicsLineItem(xs[0], ys[0], xs[1], ys[1])
line_item.setPen(
QPen(QColor(r, g, b, 128), self.gView.labelSize / 6))
gItemGroup.addToGroup(line_item)
# line_end = QGraphicsEllipseItem(xs[1], ys[1],
# int(self.gView.labelSize/3), int(self.gView.labelSize/3))
# line_end.setPen(QPen(QColor(r, g, b), 0.5))
# line_end.setBrush(QBrush(QColor(r, g, b)))
# gItemGroup.addToGroup(line_end)
pointShape = QGraphicsEllipseItem(pointBbx)
shapeColor = QColor(r, g, b, 128)
textColor = Qt.GlobalColor.black
tooltip = 'L{}:{}'
# textLabel.setRotation(np.arctan((ys[1] - ys[0])/(xs[1] - xs[0]))*(180/3.14))
else:
pointBbx.moveCenter(QPointF(np.mean(xs), np.mean(ys)))
textLabel.setPos(
np.mean(xs) - (textLabel.boundingRect().width() / 2),
np.mean(ys) - (textLabel.boundingRect().height() / 2))
points = [QPointF(x, y) for x, y in zip(xs, ys)]
polygon = QPolygonF(points)
r, g, b = np.random.choice(range(256), size=3)
zone_item = QGraphicsPolygonItem(polygon)
zone_item.setPen(QPen(QColor(r, g, b), self.gView.labelSize / 10))
zone_item.setBrush(QBrush(QColor(r, g, b, 40)))
gItemGroup.addToGroup(zone_item)
pointShape = QGraphicsRectItem(pointBbx)
shapeColor = Qt.GlobalColor.darkBlue
textColor = Qt.GlobalColor.white
tooltip = 'Z{}:{}'
pointShape.setPen(QPen(Qt.GlobalColor.white, 0.5))
pointShape.setBrush(QBrush(shapeColor))
# self.gView.scene().addEllipse(pointBbx, QPen(Qt.white, 0.5), QBrush(Qt.black))
gItemGroup.setToolTip(tooltip.format(label, type))
gItemGroup.addToGroup(pointShape)
labelFont = QFont()
labelFont.setPointSize(round(self.gView.labelSize / 2))
labelFont.setBold(True)
textLabel.setFont(labelFont)
textLabel.setDefaultTextColor(textColor)
gItemGroup.addToGroup(textLabel)
return gItemGroup