Source code for pydm.utilities.iconfont

iconfont provides a barebones system to get QIcons from icon fonts (like Font Awesome).
The inspiration and methodology come from the 'QtAwesome' module, which does exactly this, but
is a little too big, complicated, and flexible for PyDM's needs.
import json
import os
import sys
from typing import Optional

from qtpy import QtGui, QtWidgets
from qtpy.QtCore import QPoint, QRect, Qt, qRound
from qtpy.QtGui import QColor, QFont, QFontDatabase, QIcon, QIconEngine, QPainter, QPixmap

if sys.version_info[0] == 3:
    unichr = chr

[docs]class IconFont(object): """IconFont represents an icon font. Users will generally want to use IconFont.icon() to get a QIcon object for the character they want.""" __instance = None def __init__(self): if self.__initialized: return self.font_file = "fontawesome.otf" # specify these relative to this file. self.charmap_file = "fontawesome-charmap.json" self.font_name = None self.char_map = {} self.loaded_fonts = {} self.__initialized = True def __new__(cls, *args, **kwargs): if cls.__instance is None: cls.__instance = object.__new__(IconFont) cls.__instance.__initialized = False return cls.__instance
[docs] def load_font(self, ttf_filename, charmap_filename): """ Load font from ``ttf_filename`` with a mapping defined in ``charmap_filename``. """ def hook(obj): result = {} for key in obj: result[key] = unichr(int(obj[key], 16)) return result if self.char_map: return cache_key = ttf_filename + "|" + charmap_filename ttf_fname = os.path.join(os.path.dirname(os.path.realpath(__file__)), ttf_filename) font_id = QFontDatabase.addApplicationFont(ttf_fname) if font_id >= 0: font_families = QFontDatabase.applicationFontFamilies(font_id) else: cache = self.loaded_fonts.get(cache_key, None) if cache is None: raise OSError("Could not load ttf file for icon font.") self.char_map = cache["char_map"] self.font_name = cache["font_name"] return self.font_name = font_families[0] filename = os.path.join(os.path.dirname(os.path.realpath(__file__)), charmap_filename) with open(filename, "r") as codes: self.char_map = json.load(codes, object_hook=hook) self.loaded_fonts[cache_key] = { "char_map": self.char_map, "font_name": self.font_name, }
[docs] def get_char_for_name(self, name: str) -> str: """ Get a character icon for the given name from the character map. Parameters ---------- name : str The user-friendly icon name. Returns ------- str The Qt-facing icon text to use with the font. """ if name in self.char_map: return self.char_map[name] raise ValueError("Invalid icon name for font.")
def _load_font_if_needed(self) -> bool: """ Load the configured font if a QApplication is available and the font was not already loaded. Returns ------- bool Readiness indicator - return True if the font has been loaded. """ if QtWidgets.QApplication.instance() is None: return False if not self.char_map: self.load_font(self.font_file, self.charmap_file) # If it was loaded correctly, the char map will be populated: return bool(self.char_map)
[docs] def font(self, size: int) -> Optional[QtGui.QFont]: """ Load the font at a given pixel size. Returns ------- QtGui.QFont or None The font, if available. If a QApplication is not yet created, None will be returned. """ if not self._load_font_if_needed(): return None font = QFont(self.font_name) font.setPixelSize(int(size)) return font
[docs] def icon(self, name, color=None) -> Optional[QtGui.QIcon]: """ Retrieve the icon given a name and color. Parameters ---------- name : str The Icon string identifier. Icon strings can be found at: color : QColor, Optional The base color to use when constructing the Icon. Default is QColor(90, 90, 90). Returns ------- QIcon The desired Icon. ``None`` if a QApplication is not yet available. """ if not self._load_font_if_needed(): return None char = self.get_char_for_name(name) engine = CharIconEngine(self, char, color) return QIcon(engine)
class CharIconEngine(QIconEngine): """Subclass of QIconEngine that is designed to draw characters from icon fonts.""" def __init__(self, icon_font, char, color=None): super(CharIconEngine, self).__init__() self.icon_font = icon_font self.char = char if color is None: self._base_color = QColor(90, 90, 90) else: self._base_color = color self._disabled_color = QColor.fromHslF( self._base_color.hueF(), self._base_color.saturationF(), max(min(self._base_color.lightnessF() + 0.25, 1.0), 0.0), ) def paint(self, painter, rect, mode, state): if mode == QIcon.Disabled: color = self._disabled_color else: color = self._base_color painter.setPen(color) scale_factor = 1.0 draw_size = 0.875 * qRound(rect.height() * scale_factor) painter.setFont(self.icon_font.font(draw_size)) painter.setOpacity(1.0) painter.drawText(rect, int(Qt.AlignCenter | Qt.AlignVCenter), self.char) painter.restore() def pixmap(self, size, mode, state): pm = QPixmap(size) pm.fill(Qt.transparent) self.paint(QPainter(pm), QRect(QPoint(0, 0), size), mode, state) return pm