def init_win_title(self):
self.min = QPushButton()
self.shutdown = QPushButton()
self.title = QLabel('Synferlo Scrapping v1.0')
title_font = QFont()
title_font.bold()
title_font.setFamily('Consolas')
title_font.setPointSize(12)
self.title.setFont(title_font)
self.title.setAlignment(Qt.AlignCenter)
self.min.setFixedSize(15, 15)
self.shutdown.setFixedSize(15, 15)
self.min.setStyleSheet(
"""QPushButton{background:#6DDF6D;border-radius:5px;}QPushButton:hover{background:green;}"""
)
self.shutdown.setStyleSheet(
"""QPushButton{background:#F76677;border-radius:5px;}QPushButton:hover{background:red;}"""
)
# minimize the window
self.min.clicked['bool'].connect(self.showMinimized)
self.shutdown.clicked['bool'].connect(self.close)
self.win_title_layout.addWidget(self.title, 0, 0, 1, 8)
self.win_title_layout.addWidget(self.min, 0, 8, 1, 1)
self.win_title_layout.addWidget(self.shutdown, 0, 9, 1, 1)
def __init__(self):
super().__init__()
self.title = 'Donkey Kong'
self.setStyleSheet("QWidget { background-color: %s}" %
QColor(0, 0, 0).name())
self.resize(800, 600)
self.center()
pybutton1 = QPushButton('New Game', self)
pybutton1.clicked.connect(self.clickMethod1)
pybutton1.resize(180, 50)
pybutton1.move(310, 400)
font = QFont()
font.setFamily("Arcade Normal")
font.setPointSize(15)
font.bold()
pybutton1.setStyleSheet(
"QPushButton:!hover { background-color: black; color: white; }"
"QPushButton:hover { background-color: black; color: red; }")
pybutton1.setFont(font)
pybutton2 = QPushButton('Controls', self)
pybutton2.clicked.connect(self.clickMethod2)
pybutton2.resize(160, 50)
pybutton2.move(320, 500)
pybutton2.setStyleSheet(
"QPushButton:!hover { background-color: black; color: white; }"
"QPushButton:hover { background-color: black; color: red; }")
pybutton2.setFont(font)
self.initUI()
def render__label_qfont(self, qfont: QFont):
self.cfg.render.label_font = attr.evolve(
self.cfg.render.label_font,
# Font file selection
family=qfont.family(),
bold=qfont.bold(),
italic=qfont.italic(),
# Font size
size=qfont.pointSizeF(),
# QFont implementation details
toString=qfont.toString(),
)
def _setupFormat(self,
color: QColor,
fontSettings: QFont,
colorIsForeground: bool = True) -> QTextCharFormat:
pattern_format = QTextCharFormat()
if color and colorIsForeground:
pattern_format.setForeground(color)
if color and (not colorIsForeground):
pattern_format.setBackground(color)
pattern_format.setFontItalic(fontSettings.italic())
pattern_format.setFontWeight(fontSettings.bold())
return pattern_format
class NFontConverterWidget(QWidget):
data_ready_signal = pyqtSignal(NGL_Font)
def __init__(self, name, dataSlot=None, parent=None):
""" Constructor """
super(NFontConverterWidget, self).__init__(parent)
self.settings = QSettings('NeilLab', 'NGL Font')
# load main ui window
uifile = pkg_resources.resource_filename('ngl_utils.nfont',
'qtres/ngl_font.ui')
self.uic = uic.loadUi(uifile, self)
self.nfont_view = CodeView_Window(self)
self.sysFont_dialog = QFontDialog(self)
# def sysfont and font name
self.font = QFont('Times', 8)
self.NGL_Font = None
fname = NGL_Font.formatName(self.font.family(), self.font.pointSize(),
self.font.bold())
self.lineEdit_fontName.setText(fname)
# generates chars set for combobox
self._charstersRangesInit()
# font edit widget
self.edit_view = NFontEditWidget('__util__')
# connect signals / slots
self.tBtn_Font.clicked.connect(self._selectFont_slot)
self.tBtn_AddChars.clicked.connect(self._add_chars_slot)
self.tBtn_Convert.clicked.connect(self._convert_slot)
self.tBtn_Save.clicked.connect(self._saveAs_slot)
self.tBtn_ViewOut.clicked.connect(self._view_out_slot)
self.tBtn_Edit.clicked.connect(self._edit_font_slot)
if name == '__main__':
self.tBtn_Close.setText('Close')
self.tBtn_Close.clicked.connect(self._close_slot)
else:
self.tBtn_Close.setText('Add')
self.tBtn_Close.clicked.connect(self._ok_slot)
self.connectDataReadySlot(dataSlot)
# set window to center and show
self.frameGeometry().moveCenter(
QDesktopWidget().availableGeometry().center())
def connectDataReadySlot(self, dataSlot):
""" dataSlot is Qt slot for signaling converting ready state """
if dataSlot:
self.data_ready_signal.connect(dataSlot)
def _charstersRangesInit(self):
""" Init charsters sets ranges """
cm_chr = self.cmBox_chars_sets
cm_chr.insertItem(0, 'Full eng',
''.join([chr(x) for x in range(ord(' '), ord('~'))]))
cm_chr.insertItem(1, 'Upper eng (A-Z)',
''.join([chr(x) for x in range(ord('A'), ord('Z'))]))
cm_chr.insertItem(2, 'Lower eng (a-z)',
''.join([chr(x) for x in range(ord('a'), ord('z'))]))
cm_chr.insertItem(
3, 'Full rus',
''.join([chr(x) for x in range(ord(u'А'), ord(u'я'))]))
cm_chr.insertItem(
4, 'Upper rus (А-Я)',
''.join([chr(x) for x in range(ord(u'А'), ord(u'Я'))]))
cm_chr.insertItem(5, 'Lower rus (а-я)',
''.join([chr(x) for x in range(ord('а'), ord('я'))]))
cm_chr.insertItem(6, 'Full eng+rus',
cm_chr.itemData(0) + cm_chr.itemData(3))
cm_chr.insertItem(7, 'Numbers (0-9)', '0123456789')
@pyqtSlot()
def _selectFont_slot(self):
"""
Select Font slot
"""
font, font_res = self.sysFont_dialog.getFont(self.font, None,
'Select Font')
if font_res:
name = NGL_Font.formatName(font.family(), font.pointSize(),
font.bold())
self.lineEdit_fontName.setText(name)
self.font = font
@pyqtSlot()
def _add_chars_slot(self):
"""
Add charsers sets to textBrowser
"""
self.txtBrowser_chars.clear()
chars_sets = self.cmBox_chars_sets.currentData()
self.txtBrowser_chars.insertPlainText(chars_sets)
@pyqtSlot()
def _convert_slot(self):
"""
Start converting slot
"""
chars_sets = str(self.txtBrowser_chars.toPlainText())
if chars_sets:
gtime = time.time()
# converting to ngl font
name = self.lineEdit_fontName.text()
self.NGL_Font = NFontConverter.convertQFont(
chars_sets, name, self.font)
ch_list = self.NGL_Font.get_chars_list()
gtime = time.time() - gtime
self.lbl_gen_time.setText(
'converted at: %.2f sec | estimate code size: ~%0.3fk' %
(gtime, self.NGL_Font.code_size_calc() / 1000))
self.lbl_gen_time.update()
else:
QMessageBox.critical(
self, 'ERROR', """ Nothing to convert!
Add singles char or characters set to textbox first""")
@pyqtSlot()
def _view_out_slot(self, nfont=None):
""" View converting out code """
if nfont == None:
self.nfont_view.view(self.NGL_Font)
else:
self.nfont_view.view(nfont)
@pyqtSlot()
def _edit_font_slot(self):
odir = self.settings.value('open_last_dir', type=str)
if not odir:
odir = './'
fileName, _ = QFileDialog.getOpenFileName(
self,
"Open NGL Font source for edit",
odir,
"Source ngl font Files (*.c);;All Files (*)",
options=QFileDialog.DontUseNativeDialog)
if fileName:
self.settings.setValue('open_last_dir', os.path.dirname(fileName))
# set parsed ngl font and show edit widget
self.edit_view.setFontFile(fileName)
self.edit_view.show()
def _save(self, filepath, font):
with open(filepath, 'w') as f:
f.write(font.get_code().replace('\r\n', '\n'))
@pyqtSlot()
def _saveAs_slot(self):
"""
Save out to file
"""
if self.NGL_Font:
file_name, sts = QFileDialog.getSaveFileName(
self,
"QFileDialog.getSaveFileName()",
self.NGL_Font.name,
"C files (*.c)",
options=QFileDialog.Options()
| QFileDialog.DontUseNativeDialog)
if sts:
self._save(file_name + '.c', self.NGL_Font)
@pyqtSlot()
def _ok_slot(self):
if self.NGL_Font:
self.data_ready_signal.emit(self.NGL_Font)
else:
QMessageBox.critical(self, 'ERROR', 'Font not convert!')
@pyqtSlot()
def _close_slot(self):
self.close()
def keyPressEvent(self, e):
if e.key() == Qt.Key_Escape:
self._close_slot()
class Main(Widget, QWidget):
def __init__(self, widget_manager, info):
# init
Widget.__init__(self, widget_manager, info)
QWidget.__init__(self)
self.conf = {}
self.lang = info.lang
self.settings_win = None
# setup layout
self.setLayout(QVBoxLayout(self))
self.layout().setContentsMargins(0, 0, 0, 0)
# setup stylesheet
with open(os.path.join(RES, 'net_stat', 'style.css'),
encoding='utf-8') as file:
style = file.read()
self.setStyleSheet(style)
self.setAttribute(Qt.WA_TranslucentBackground)
# setup timer
self.timer = QTimer(self)
self.timer.timeout.connect(self.setup_ui)
# setup vars
self.stats = psutil.net_if_stats()
self._widgets = []
self._setup_vars()
def _setup_vars(self):
self._update = 1000
self._round = 3
self._labels = True
self._pername = False
self._names = [tuple(self.stats.keys())[0]]
self._bar = True
self._text = True
self._srecv = True
self._ssent = True
self._trecv = True
self._tsent = True
self._precv = False
self._psent = False
self._errin = False
self._errout = False
self._dropin = False
self._dropout = False
self._con = True
self._kind = 'inet'
self._mbit = False
self._old_counters = None
self._max_recv_speed = 0
self._max_sent_speed = 0
self._palette = QPalette()
self._palette.setColor(QPalette.WindowText, QColor('#000000'))
self._font = QFont()
@try_except()
def setup_ui(self):
if self._widgets: # clear
for w in self._widgets:
self.layout().removeWidget(w)
w.deleteLater()
self._widgets.clear()
# setup elements
if not self._labels:
self._add_label(self.lang['net'])
counters = psutil.net_io_counters(self._pername)
speed = False
if self._old_counters and type(counters) == type(self._old_counters):
speed = True
else:
self._old_counters = counters
names = self._names if self._pername else [None]
for name in names:
if name:
if name not in counters:
return
if self._labels:
self._add_label(self.lang['net_name'].format(name))
if speed:
self.__setup_speed(counters, name)
self.__setup_total(counters, name)
self.__setup_packets(counters, name)
self.__setup_errors(counters, name)
self.__setup_drops(counters, name)
self.__setup_con()
# set layout
self.layout().update()
def get_rate_locale(self, rate) -> str:
if rate == Rate.B:
return self.lang['b']
elif rate == Rate.KIB:
return self.lang['kib']
elif rate == Rate.MIB:
return self.lang['mib']
elif rate == Rate.GIB:
return self.lang['gib']
elif rate == Rate.TIB:
return self.lang['tib']
elif rate == Rate.MBIT:
return self.lang['mbit']
def _add_label(self, text):
label = QLabel(text, self)
label.setAlignment(Qt.AlignCenter)
label.setPalette(self._palette)
label.setFont(self._font)
self._widgets.append(label)
self.layout().addWidget(label)
def _add_rate_label(self, b, loc_str):
if self._mbit:
value = get_mbit(b)
rate = Rate.MBIT
else:
value, rate = get_rate(b)
value = round(value, self._round)
self._add_label(
loc_str.format(count=value, rate=self.get_rate_locale(rate)))
def __setup_speed(self, counters, name=None):
def setup_bar(b, max_b):
if not self._bar:
return
bar = QProgressBar(self)
bar.setMinimum(0)
bar.setMaximum(100)
bar.setValue(get_percent(b, max_b))
self._widgets.append(bar)
self.layout().addWidget(bar)
def get_max_speed() -> float:
result = 0
for name in self.stats:
if self.stats[name].speed > result:
result = self.stats[name].speed
return get_bytes_from_mbit(result)
def get_speed(speed, name) -> float:
result = speed
if name:
if name in self.stats and self.stats[name].speed:
result = get_bytes_from_mbit(self.stats[name].speed)
else:
speed2 = get_max_speed()
if speed2 > speed:
result = speed2
return result
if name:
recv_speed = (counters[name].bytes_recv -
self._old_counters[name].bytes_recv)
sent_speed = (counters[name].bytes_sent -
self._old_counters[name].bytes_sent)
else:
recv_speed = (counters.bytes_recv - self._old_counters.bytes_recv)
sent_speed = (counters.bytes_sent - self._old_counters.bytes_sent)
if self._srecv:
if recv_speed > self._max_recv_speed:
self._max_recv_speed = recv_speed
setup_bar(recv_speed, get_speed(self._max_recv_speed, name))
if self._text:
self._add_rate_label(recv_speed, self.lang['speed_recv'])
if self._ssent:
if sent_speed > self._max_sent_speed:
self._max_sent_speed = sent_speed
setup_bar(sent_speed, get_speed(self._max_sent_speed, name))
if self._text:
self._add_rate_label(sent_speed, self.lang['speed_sent'])
self._old_counters = counters
def __setup_total(self, counters, name=None):
if self._trecv:
b = counters[name].bytes_recv if name else counters.bytes_recv
self._add_rate_label(b, self.lang['total_recv'])
if self._tsent:
b = counters[name].bytes_sent if name else counters.bytes_sent
self._add_rate_label(b, self.lang['total_sent'])
def __setup_packets(self, counters, name=None):
if self._precv:
p = counters[name].packets_recv if name else counters.packets_recv
self._add_label(self.lang['packets_recv'].format(str(p)))
if self._psent:
p = counters[name].packets_sent if name else counters.packets_sent
self._add_label(self.lang['packets_sent'].format(str(p)))
def __setup_errors(self, counters, name=None):
if self._errin:
e = counters[name].errin if name else counters.errin
self._add_label(self.lang['errin'].format(str(e)))
if self._errout:
e = counters[name].errout if name else counters.errout
self._add_label(self.lang['errout'].format(str(e)))
def __setup_drops(self, counters, name=None):
if self._dropin:
d = counters[name].dropin if name else counters.dropin
self._add_label(self.lang['dropin'].format(str(d)))
if self._dropout:
d = counters[name].dropout if name else counters.dropout
self._add_label(self.lang['dropout'].format(str(d)))
def __setup_con(self):
if self._con:
con = str(len(psutil.net_connections(self._kind)))
self._add_label(self.lang['connections'].format(con))
def _load_settings(self):
self.conf = self.widget_manager.get_config(self.info.NAME)
if 'update' in self.conf:
self._update = int(self.conf['update'])
if 'round' in self.conf:
self._round = int(self.conf['round'])
if 'labels' in self.conf:
self._labels = bool(strtobool(self.conf['labels']))
if 'pername' in self.conf:
self._pername = bool(strtobool(self.conf['pername']))
if 'names' in self.conf:
self._names = json.loads(self.conf['names'])
if 'bar' in self.conf:
self._bar = bool(strtobool(self.conf['bar']))
if 'text' in self.conf:
self._text = bool(strtobool(self.conf['text']))
if 'srecv' in self.conf:
self._srecv = bool(strtobool(self.conf['srecv']))
if 'ssent' in self.conf:
self._ssent = bool(strtobool(self.conf['ssent']))
if 'trecv' in self.conf:
self._trecv = bool(strtobool(self.conf['trecv']))
if 'tsent' in self.conf:
self._tsent = bool(strtobool(self.conf['tsent']))
if 'precv' in self.conf:
self._precv = bool(strtobool(self.conf['precv']))
if 'psent' in self.conf:
self._psent = bool(strtobool(self.conf['psent']))
if 'errin' in self.conf:
self._errin = bool(strtobool(self.conf['errin']))
if 'errout' in self.conf:
self._errout = bool(strtobool(self.conf['errout']))
if 'dropin' in self.conf:
self._dropin = bool(strtobool(self.conf['dropin']))
if 'dropout' in self.conf:
self._dropout = bool(strtobool(self.conf['dropout']))
if 'con' in self.conf:
self._con = bool(strtobool(self.conf['con']))
if 'kind' in self.conf:
self._kind = self.conf['kind']
if 'mbit' in self.conf:
self._mbit = bool(strtobool(self.conf['mbit']))
if 'color' in self.conf:
self._palette.setColor(QPalette.WindowText,
QColor(self.conf['color']))
if 'size' in self.conf:
self._font.setPointSize(int(self.conf['size']))
if 'bold' in self.conf:
self._font.setBold(bool(strtobool(self.conf['bold'])))
@try_except()
def save_settings(self):
self.conf['update'] = str(self._update)
self.conf['round'] = str(self._round)
self.conf['labels'] = str(self._labels)
self.conf['pername'] = str(self._pername)
self.conf['names'] = json.dumps(self._names)
self.conf['bar'] = str(self._bar)
self.conf['text'] = str(self._text)
self.conf['srecv'] = str(self._srecv)
self.conf['ssent'] = str(self._ssent)
self.conf['trecv'] = str(self._trecv)
self.conf['tsent'] = str(self._tsent)
self.conf['precv'] = str(self._precv)
self.conf['psent'] = str(self._psent)
self.conf['errin'] = str(self._errin)
self.conf['errout'] = str(self._errout)
self.conf['dropin'] = str(self._dropin)
self.conf['dropout'] = str(self._dropout)
self.conf['con'] = str(self._con)
self.conf['kind'] = self._kind
self.conf['mbit'] = str(self._mbit)
self.conf['color'] = self._palette.color(QPalette.WindowText).name()
self.conf['size'] = str(self._font.pointSize())
self.conf['bold'] = str(self._font.bold())
@try_except()
def show_settings(self):
self.settings_win = Settings(self)
def unload(self):
self.save_settings()
def place(self):
self.resize(200, 200)
self._load_settings()
def boot(self):
self._load_settings()
def remove(self):
self.timer.stop()
def purge(self):
self.timer.stop()
self._setup_vars()
@try_except()
def showEvent(self, event):
self.setup_ui()
self.timer.start(self._update)
@try_except()
def hideEvent(self, event):
self.timer.stop()
class Text(DesignItem):
def __init__(self, text, scene):
super(Text, self).__init__(scene)
self.font = QFont("Arial")
self.font.setPointSize(14)
self.font.setStyleName("Standard")
self.text = text
self.textcolor = QColor(Qt.black)
self.data = str.encode(self.getSvg())
self.renderer = QSvgRenderer()
self.renderer.load(self.data)
self.svg = QGraphicsSvgItem(self)
self.svg.setSharedRenderer(self.renderer)
self.setRect(0, 0,
self.svg.boundingRect().width(),
self.svg.boundingRect().height())
def typeName(self):
return "Text"
def paint(self, paint, option, widget):
if option.state & QStyle.State_Selected:
self.drawHighlightSelected(paint, option)
def getTextTag(self, id):
fm = QFontMetrics(self.font)
svg = "<text "
if id:
svg += "id=\"" + id + "\" "
svg += "x=\"0\" y=\"" + str(fm.ascent()) + "\" "
svg += "font-family=\"" + self.font.family() + "\" "
svg += "font-size=\"" + str(self.font.pointSize() * 1.25) + "px\" "
if self.font.bold():
svg += "font-weight=\"bold\" "
if self.font.italic():
svg += "font-style=\"italic\" "
svg += "fill=\"" + self.textcolor.name() + "\" "
svg += "opacity=\"" + str(self.opacity()) + "\" "
svg += ">"
svg += self.text
svg += "</text>"
return svg
def getSvg(self):
font = QFont(self.font.family())
font.setBold(self.font.bold())
font.setItalic(self.font.italic())
font.setPixelSize(self.font.pointSize() * 1.25)
fm = QFontMetrics(font)
self.width = fm.width(self.text) + 2
self.height = fm.height()
svg = "<svg width=\"" + str(self.width) + "\" "
svg += "height=\"" + str(self.height) + "\" >"
svg += self.getTextTag("")
svg += "</svg>"
return svg
def setScale(self, x, y):
self.xscale = x
self.yscale = y
trans = QTransform()
trans.scale(self.xscale, self.yscale)
self.svg.setTransform(trans)
self.setRect(0, 0,
self.svg.boundingRect().width() * x,
self.svg.boundingRect().height() * y)
def scaleObjects(self):
self.xscale = self.rect.width() / self.svg.boundingRect().width()
self.yscale = self.rect.height() / self.svg.boundingRect().height()
trans = QTransform()
trans.scale(self.xscale, self.yscale)
self.svg.setTransform(trans)
class Main(Widget, QWidget):
def __init__(self, widget_manager, info):
# init
Widget.__init__(self, widget_manager, info)
QWidget.__init__(self)
self.conf = {}
self.lang = info.lang
self.settings_win = None
# setup layout
self.setLayout(QVBoxLayout(self))
self.layout().setContentsMargins(0, 0, 0, 0)
# setup stylesheet
with open(os.path.join(RES, 'ram', 'style.css'),
encoding='utf-8') as file:
style = file.read()
self.setStyleSheet(style)
self.setAttribute(Qt.WA_TranslucentBackground)
# setup timer
self.timer = QTimer(self)
self.timer.timeout.connect(self.setup_ui)
# setup vars
self._widgets = []
self._setup_vars()
def _setup_vars(self):
self._update = 1000
self._round = 3
self._labels = True
self._text = True
self._mb = False
self._ram = True
self._swap = True
self._palette = QPalette()
self._palette.setColor(QPalette.WindowText, QColor('#000000'))
self._font = QFont()
def __set_info(self, swap=False):
mem = psutil.swap_memory() if swap else psutil.virtual_memory()
p = pow(2, 20) if self._mb else pow(2, 30)
total = round(mem.total / p, self._round)
used = round(mem.used / p if swap else (mem.total - mem.available) / p,
self._round)
percent = round(
mem.percent if swap else
(mem.total - mem.available) / mem.total * 100, 0)
if self._labels:
text = self.lang['swap'] if swap else self.lang['ram']
label = QLabel(text, self)
label.setAlignment(Qt.AlignCenter)
label.setPalette(self._palette)
label.setFont(self._font)
self._widgets.append(label)
self.layout().addWidget(label)
bar = QProgressBar(self)
bar.setMinimum(0)
bar.setMaximum(100)
bar.setValue(percent)
self._widgets.append(bar)
self.layout().addWidget(bar)
if self._text:
text = self.lang['text_mb'] if self._mb else \
self.lang['text_gb']
d = {'t': str(total), 'u': str(used)}
label = QLabel(text.format(**d), self)
label.setAlignment(Qt.AlignCenter)
label.setPalette(self._palette)
label.setFont(self._font)
self._widgets.append(label)
self.layout().addWidget(label)
@try_except()
def setup_ui(self):
if self._widgets: # clear
for w in self._widgets:
self.layout().removeWidget(w)
w.deleteLater()
self._widgets.clear()
# setup elements
if self._ram:
self.__set_info()
if self._swap:
self.__set_info(True)
# set layout
self.layout().update()
def _load_settings(self):
self.conf = self.widget_manager.get_config(self.info.NAME)
if 'update' in self.conf:
self._update = int(self.conf['update'])
if 'round' in self.conf:
self._round = int(self.conf['round'])
if 'labels' in self.conf:
self._labels = bool(strtobool(self.conf['labels']))
if 'text' in self.conf:
self._text = bool(strtobool(self.conf['text']))
if 'mb' in self.conf:
self._mb = bool(strtobool(self.conf['mb']))
if 'ram' in self.conf:
self._ram = bool(strtobool(self.conf['ram']))
if 'swap' in self.conf:
self._swap = bool(strtobool(self.conf['swap']))
if 'color' in self.conf:
self._palette.setColor(QPalette.WindowText,
QColor(self.conf['color']))
if 'size' in self.conf:
self._font.setPointSize(int(self.conf['size']))
if 'bold' in self.conf:
self._font.setBold(bool(strtobool(self.conf['bold'])))
def save_settings(self):
self.conf['update'] = str(self._update)
self.conf['round'] = str(self._round)
self.conf['labels'] = str(self._labels)
self.conf['text'] = str(self._text)
self.conf['mb'] = str(self._mb)
self.conf['ram'] = str(self._ram)
self.conf['swap'] = str(self._swap)
self.conf['color'] = self._palette.color(QPalette.WindowText).name()
self.conf['size'] = str(self._font.pointSize())
self.conf['bold'] = str(self._font.bold())
@try_except()
def show_settings(self):
self.settings_win = Settings(self)
def unload(self):
self.save_settings()
def place(self):
self.resize(200, 200)
self._load_settings()
def boot(self):
self._load_settings()
def remove(self):
self.timer.stop()
def purge(self):
self.timer.stop()
self._setup_vars()
@try_except()
def showEvent(self, event):
self.setup_ui()
self.timer.start(self._update)
@try_except()
def hideEvent(self, event):
self.timer.stop()
class Main(Widget, QWidget):
def __init__(self, widget_manager, info):
# init
Widget.__init__(self, widget_manager, info)
QWidget.__init__(self)
self.conf = {}
self.lang = info.lang
self.settings_win = None
# setup layout
self.setLayout(QVBoxLayout(self))
self.layout().setContentsMargins(0, 0, 0, 0)
# setup stylesheet
with open(os.path.join(RES, 'cpu', 'style.css'),
encoding='utf-8') as file:
style = file.read()
self.setStyleSheet(style)
self.setAttribute(Qt.WA_TranslucentBackground)
# setup timer
self.timer = QTimer(self)
self.timer.timeout.connect(self.setup_ui)
# setup vars
self._widgets = []
self._setup_vars()
def _setup_vars(self):
self._update = 1000
self._round = 3
self._percpu = False
self._percent = True
self._freq = True
self._labels = True
self._text = True
self._palette = QPalette()
self._palette.setColor(QPalette.WindowText, QColor('#000000'))
self._font = QFont()
@try_except()
def setup_ui(self):
if self._widgets: # clear
for w in self._widgets:
self.layout().removeWidget(w)
w.deleteLater()
self._widgets.clear()
# setup elements
for i in range(psutil.cpu_count() if self._percpu else 1):
if self._percent: # percents
pc = psutil.cpu_percent(percpu=self._percpu)
if self._labels: # titles
text = self.lang['proc']
if self._percpu:
text = self.lang['core'].format(str(i))
label = QLabel(text, self)
label.setAlignment(Qt.AlignCenter)
self._widgets.append(label)
self.layout().addWidget(label)
bar = QProgressBar(self)
bar.setMinimum(0)
bar.setMaximum(100)
bar.setValue(int(pc[i]) if self._percpu else int(pc))
self._widgets.append(bar)
self.layout().addWidget(bar)
if self._freq and 'cpu_freq' in psutil.__dict__: # freqs
pf = psutil.cpu_freq(self._percpu)
if self._labels: # titles
text = self.lang['freq']
if self._percpu:
text = self.lang['core_freq'].format(str(i))
label = QLabel(text, self)
label.setAlignment(Qt.AlignCenter)
label.setPalette(self._palette)
label.setFont(self._font)
self._widgets.append(label)
self.layout().addWidget(label)
bar = QProgressBar(self)
bar.setMinimum(int(pf[i].min) if self._percpu else int(pf.min))
bar.setMaximum(int(pf[i].max) if self._percpu else int(pf.max))
bar.setValue(
int(pf[i].current) if self._percpu else int(pf.current))
self._widgets.append(bar)
self.layout().addWidget(bar)
if self._text: # text info
text = str(round(pf[i].current, self._round)) if \
self._percpu else \
str(round(pf.current, self._round))
label = QLabel(self.lang['freq_text'].format(text))
label.setAlignment(Qt.AlignCenter)
label.setPalette(self._palette)
label.setFont(self._font)
self._widgets.append(label)
self.layout().addWidget(label)
# set layout
self.layout().update()
def _load_settings(self):
self.conf = self.widget_manager.get_config(self.info.NAME)
if 'update' in self.conf:
self._update = int(self.conf['update'])
if 'round' in self.conf:
self._round = int(self.conf['round'])
if 'percpu' in self.conf:
self._percpu = bool(strtobool(self.conf['percpu']))
if 'percent' in self.conf:
self._percent = bool(strtobool(self.conf['percent']))
if 'freq' in self.conf:
self._freq = bool(strtobool(self.conf['freq']))
if 'labels' in self.conf:
self._labels = bool(strtobool(self.conf['labels']))
if 'text' in self.conf:
self._text = bool(strtobool(self.conf['text']))
if 'color' in self.conf:
self._palette.setColor(QPalette.WindowText,
QColor(self.conf['color']))
if 'size' in self.conf:
self._font.setPointSize(int(self.conf['size']))
if 'bold' in self.conf:
self._font.setBold(bool(strtobool(self.conf['bold'])))
@try_except()
def save_settings(self):
self.conf['update'] = str(self._update)
self.conf['round'] = str(self._round)
self.conf['percpu'] = str(self._percpu)
self.conf['percent'] = str(self._percent)
self.conf['freq'] = str(self._freq)
self.conf['labels'] = str(self._labels)
self.conf['text'] = str(self._text)
self.conf['color'] = self._palette.color(QPalette.WindowText).name()
self.conf['size'] = str(self._font.pointSize())
self.conf['bold'] = str(self._font.bold())
@try_except()
def show_settings(self):
self.settings_win = Settings(self)
def unload(self):
self.save_settings()
def place(self):
self.resize(200, 200)
self._load_settings()
def boot(self):
self._load_settings()
def remove(self):
self.timer.stop()
def purge(self):
self.timer.stop()
self._setup_vars()
@try_except()
def showEvent(self, event):
self.setup_ui()
self.timer.start(self._update)
@try_except()
def hideEvent(self, event):
self.timer.stop()
