def load_font(self, ttf_filename, charmap_filename): def hook(obj): result = {} for key in obj: result[key] = unichr(int(obj[key], 16)) return result if self.char_map is None: 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.") else: self.char_map = cache['char_map'] self.font_name = cache['font_name'] return self.font_name = font_families[0] with open(os.path.join(os.path.dirname(os.path.realpath(__file__)), charmap_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}
def load_font(self, ttf_filename, charmap_filename): def hook(obj): result = {} for key in obj: result[key] = unichr(int(obj[key], 16)) return result if self.char_map is None: 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.") else: self.char_map = cache['char_map'] self.font_name = cache['font_name'] return self.font_name = font_families[0] with open( os.path.join(os.path.dirname(os.path.realpath(__file__)), charmap_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 }
def bootstrap(cfgmgr, theme='Breeze', aot=True, debug__no_scrcpy=False, hide_wm_frame=True): """ Launch the guiscrcpy window :return: """ config = cfgmgr.get_config() # enable High DPI scaling QApplication.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling, True) # use HIGH DPI icons QApplication.setAttribute(QtCore.Qt.AA_UseHighDpiPixmaps, True) # init core app = QtWidgets.QApplication([]) # load fonts font_database = QFontDatabase() for font in FONTS: s = font_database.addApplicationFont( ':/font/fonts/{ttf}'.format(ttf=font)) if s == -1: # loading the font failed # https://doc.qt.io/qt-5/qfontdatabase.html print(fc("{y}Failed to load {ttf} font.{rst}", ttf=font)) # set theme app.setStyle(theme) # apply stylesheet if theme == 'Breeze': # The Qdarkstylesheet is based on Breeze, lets load them on default app.setStyleSheet(dark_stylesheet()) # load splash splash_pix = QPixmap(":/res/ui/guiscrcpy-branding.png") splash = QtWidgets.QSplashScreen(splash_pix) splash.setMask(splash_pix.mask()) splash.show() app.processEvents() # on windows, users are likely not to add the scrcpy-server to the # SCRCPY_SERVER_PATH cfgmgr.update_config(set_scrcpy_server_path(config)) cfgmgr.write_file() adb = AndroidDebugBridge(cfgmgr.get_config().get('adb')) scrcpy = ScrcpyBridge(cfgmgr.get_config().get('scrcpy')) cfgmgr['adb'] = adb.get_path() cfgmgr['scrcpy'] = scrcpy.get_path() guiscrcpy = InterfaceGuiscrcpy(cfgmgr=cfgmgr, adb=adb, scrcpy=scrcpy, force_window_frame=not hide_wm_frame, panels_not_always_on_top=not aot, debug__no_scrcpy=debug__no_scrcpy) guiscrcpy.show() app.processEvents() splash.hide() app.exec_()
def bootstrap( app: QtWidgets.QApplication, config_manager: InterfaceConfig, theme: str = "Breeze", aot: bool = True, debug_no_scrcpy: bool = False, hide_wm_frame: bool = True, ): """ Launch the guiscrcpy window :return: """ config = config_manager.get_config() # load fonts font_database = QFontDatabase() for font in FONTS: s = font_database.addApplicationFont( ":/font/fonts/{ttf}".format(ttf=font)) if s == -1: # loading the font failed # https://doc.qt.io/qt-5/qfontdatabase.html print(fc("{y}Failed to load {ttf} font.{rst}", ttf=font)) # set theme app.setStyle(theme) # apply stylesheet if theme == "Breeze": # The Qdarkstylesheet is based on Breeze, lets load them on default app.setStyleSheet(dark_stylesheet()) # load splash splash_pix = QPixmap(":/res/ui/guiscrcpy-branding.png") splash = QtWidgets.QSplashScreen(splash_pix) splash.setMask(splash_pix.mask()) splash.show() app.processEvents() # on windows, users are likely not to add the scrcpy-server to the # SCRCPY_SERVER_PATH config_manager.update_config(set_scrcpy_server_path(config)) config_manager.write_file() adb = AndroidDebugBridge(config_manager.get_config().get("adb")) scrcpy = ScrcpyBridge(config_manager.get_config().get("scrcpy")) config_manager["adb"] = adb.get_path() config_manager["scrcpy"] = scrcpy.get_path() guiscrcpy = InterfaceGuiscrcpy( config_manager=config_manager, adb=adb, scrcpy=scrcpy, force_window_frame=not hide_wm_frame, panels_not_always_on_top=not aot, debug_no_scrcpy=debug_no_scrcpy, ) guiscrcpy.show() app.processEvents() splash.hide() app.exec_()
def __init__(self, config: Config) -> None: """ Main window with the GUI and whatever player is being used. """ super().__init__() self.setWindowTitle('vidify') # Setting the window to stay on top if config.stay_on_top: self.setWindowFlags(Qt.WindowStaysOnTopHint) # Setting the fullscreen and window size if config.fullscreen: self.showFullScreen() else: self.resize(config.width or 800, config.height or 600) self.layout = QHBoxLayout(self) self.layout.setContentsMargins(0, 0, 0, 0) self.layout.setSpacing(0) # Loading the used fonts (Inter) font_db = QFontDatabase() for font in Res.fonts: font_db.addApplicationFont(font) # Initializing the player and saving the config object in the window. self.player = initialize_player(config.player, config) logging.info("Using %s as the player", config.player) self.config = config # The audiosync feature is optional until it's more stable. if self.config.audiosync: from vidify.audiosync import AudiosyncWorker self.audiosync = AudiosyncWorker() else: self.audiosync = None # The API initialization is more complex. For more details, please # check the flow diagram in vidify.api. First we have to check if # the API is saved in the config: try: api_data = get_api_data(config.api) except KeyError: # Otherwise, the user is prompted for an API. After choosing one, # it will be initialized from outside this function. logging.info("API not found: prompting the user") self.API_selection = APISelection() self.layout.addWidget(self.API_selection) self.API_selection.api_chosen.connect(self.on_api_selection) else: logging.info("Using %s as the API", config.api) self.initialize_api(api_data)
def _test_imports(): print("start_test_import") from qtpy.QtWidgets import QApplication app = QApplication([]) from napari._qt.widgets.qt_console import QtConsole from PartSeg import plugins from PartSeg._launcher.main_window import MainWindow from PartSeg._roi_analysis.main_window import MainWindow as AnalysisMain from PartSeg._roi_mask.main_window import MainWindow as MaskMain from PartSeg.common_backend.base_argparser import _setup_sentry _setup_sentry() plugins.register() w1 = AnalysisMain("test") w2 = MaskMain("test") w3 = MainWindow("test") console = QtConsole() if QFontDatabase.addApplicationFont(os.path.join(font_dir, "Symbola.ttf")) == -1: raise ValueError("Error with loading Symbola font") del w1 del w2 del w3 del app del console print("end_test_import")
def text_font(): """Return the first monospace font for this system. The font is cached on first access. """ global _TEXT_FONT_CACHE if _TEXT_FONT_CACHE is None: fontdb = QFontDatabase() families = fontdb.families() for family in MONOSPACE: if family in families: _TEXT_FONT_CACHE = QFont(family) break _TEXT_FONT_CACHE.setPointSize(PT_SIZE) _TEXT_FONT_CACHE.setFixedPitch(True) return _TEXT_FONT_CACHE
def load_font(font_name, font_file): # NOTE: you need to have created a QApplication() first (see # qtw.Widgets.Application) for this to work correctly, or you will get # a crash! font_id = QFontDatabase.addApplicationFont(font_file) if font_id < 0: raise ValueError("Unspecified Qt problem loading font from '%s'" % (font_file)) font_family = QFontDatabase.applicationFontFamilies(font_id)[0] if font_name != font_family: # If Qt knows this under a different name, add an alias font_asst.add_alias(font_name, font_family) return font_name
def loadFont(self, font_path): """Loads a font file into the font database. The path can specify the location of a font file or a qresource.""" LOG.debug("Loading custom font: %s" % font_path) res = QFontDatabase.addApplicationFont(font_path) if res != 0: LOG.error("Failed to load font: %s", font_path)
def load_font(font_name, font_file): # NOTE: you need to have created a QApplication() first (see # qtw.Widgets.Application) for this to work correctly, or you will get # a crash! font_id = QFontDatabase.addApplicationFont(font_file) if font_id < 0: raise ValueError("Unspecified Qt problem loading font from '%s'" % ( font_file)) font_family = QFontDatabase.applicationFontFamilies(font_id)[0] if font_name != font_family: # If Qt knows this under a different name, add an alias font_asst.add_alias(font_name, font_family) return font_name
def readSettings(self, settings): qapp = QApplication.instance() # get the saved window geometry window_size = settings.get('MainWindow/size') if not isinstance(window_size, QSize): window_size = QSize(*window_size) window_pos = settings.get('MainWindow/position') if not isinstance(window_pos, QPoint): window_pos = QPoint(*window_pos) if settings.has('MainWindow/font'): font_string = settings.get('MainWindow/font').split(',') font = QFontDatabase().font(font_string[0], font_string[-1], int(font_string[1])) qapp.setFont(font) # reset font for ipython console to ensure it stays monospace self.ipythonconsole.console.reset_font() # make sure main window is smaller than the desktop desktop = QDesktopWidget() # this gives the maximum screen number if the position is off screen screen = desktop.screenNumber(window_pos) # recalculate the window size desktop_geom = desktop.availableGeometry(screen) w = min(desktop_geom.size().width(), window_size.width()) h = min(desktop_geom.size().height(), window_size.height()) window_size = QSize(w, h) # and position it on the supplied desktop screen x = max(window_pos.x(), desktop_geom.left()) y = max(window_pos.y(), desktop_geom.top()) if x + w > desktop_geom.right(): x = desktop_geom.right() - w if y + h > desktop_geom.bottom(): y = desktop_geom.bottom() - h window_pos = QPoint(x, y) # set the geometry self.resize(window_size) self.move(window_pos) # restore window state if settings.has('MainWindow/state'): if not self.restoreState(settings.get('MainWindow/state'), SAVE_STATE_VERSION): logger.warning( "The previous layout of workbench is not compatible with this version, reverting to default layout." ) else: self.setWindowState(Qt.WindowMaximized) # read in settings for children AlgorithmInputHistory().readSettings(settings) for widget in self.widgets: if hasattr(widget, 'readSettingsIfNotDone'): widget.readSettingsIfNotDone(settings)
def action_main_font_button_clicked(self): font = None if CONF.has(GeneralProperties.FONT.value): font_string = CONF.get(GeneralProperties.FONT.value).split(',') if len(font_string) > 2: font = QFontDatabase().font(font_string[0], font_string[-1], int(font_string[1])) font_dialog = self.view.create_font_dialog(self.parent, font) font_dialog.fontSelected.connect(self.action_font_selected)
def addApplicationFont(self, font_path): """Loads a font file into the font database. The path can specify the location of a font file or a qresource.""" LOG.debug("Loading custom font: %s" % font_path) res = QFontDatabase.addApplicationFont(font_path) # per QT docs -1 is error and 0+ is index to font loaded for later use if res < 0: LOG.error("Failed to load font: %s", font_path)
def readSettings(self, settings): qapp = QApplication.instance() qapp.setAttribute(Qt.AA_UseHighDpiPixmaps) if hasattr(Qt, 'AA_EnableHighDpiScaling'): qapp.setAttribute(Qt.AA_EnableHighDpiScaling, settings.get('high_dpi_scaling')) # get the saved window geometry window_size = settings.get('MainWindow/size') if not isinstance(window_size, QSize): window_size = QSize(*window_size) window_pos = settings.get('MainWindow/position') if not isinstance(window_pos, QPoint): window_pos = QPoint(*window_pos) if settings.has('MainWindow/font'): font_string = settings.get('MainWindow/font').split(',') font = QFontDatabase().font(font_string[0], font_string[-1], int(font_string[1])) qapp.setFont(font) # make sure main window is smaller than the desktop desktop = QDesktopWidget() # this gives the maximum screen number if the position is off screen screen = desktop.screenNumber(window_pos) # recalculate the window size desktop_geom = desktop.availableGeometry(screen) w = min(desktop_geom.size().width(), window_size.width()) h = min(desktop_geom.size().height(), window_size.height()) window_size = QSize(w, h) # and position it on the supplied desktop screen x = max(window_pos.x(), desktop_geom.left()) y = max(window_pos.y(), desktop_geom.top()) if x + w > desktop_geom.right(): x = desktop_geom.right() - w if y + h > desktop_geom.bottom(): y = desktop_geom.bottom() - h window_pos = QPoint(x, y) # set the geometry self.resize(window_size) self.move(window_pos) # restore window state if settings.has('MainWindow/state'): self.restoreState(settings.get('MainWindow/state')) else: self.setWindowState(Qt.WindowMaximized) # read in settings for children AlgorithmInputHistory().readSettings(settings) for widget in self.widgets: if hasattr(widget, 'readSettings'): widget.readSettings(settings)
def load_font(self, prefix, ttf_filename, charmap_filename, directory=None): """Loads a font file and the associated charmap If `directory` is None, the files will be looked up in ./fonts/ Arguments --------- prefix: str prefix string to be used when accessing a given font set ttf_filename: str ttf font filename charmap_filename: str charmap filename directory: str or None, optional directory for font and charmap files """ def hook(obj): result = {} for key in obj: result[key] = unichr(int(obj[key], 16)) return result if directory is None: directory = os.path.join( os.path.dirname(os.path.realpath(__file__)), 'fonts') with open(os.path.join(directory, ttf_filename), 'rb') as f: font_data = QByteArray(f.read()) with open(os.path.join(directory, charmap_filename), 'r') as codes: self.charmap[prefix] = json.load(codes, object_hook=hook) id_ = QFontDatabase.addApplicationFontFromData(font_data) loadedFontFamilies = QFontDatabase.applicationFontFamilies(id_) if (loadedFontFamilies): self.fontname[prefix] = loadedFontFamilies[0] else: print('Font is empty')
def start_ryven(): # import windows from MainConsole import init_main_console from startup_dialog.StartupDialog import StartupDialog from MainWindow import MainWindow # init application from qtpy.QtWidgets import QApplication app = QApplication(sys.argv) # register fonts from qtpy.QtGui import QFontDatabase db = QFontDatabase() db.addApplicationFont('../resources/fonts/poppins/Poppins-Medium.ttf') db.addApplicationFont('../resources/fonts/source_code_pro/SourceCodePro-Regular.ttf') db.addApplicationFont('../resources/fonts/asap/Asap-Regular.ttf') # StartupDialog sw = StartupDialog() sw.exec_() # exit if dialog couldn't initialize if sw.editor_startup_configuration == {}: sys.exit() window_theme = sw.window_theme # init main console console_stdout_redirect, \ console_errout_redirect = init_main_console(window_theme) # init main window mw = MainWindow(sw.editor_startup_configuration, window_theme) mw.show() if REDIRECT_CONSOLE_OUTPUT: # redirect console output from contextlib import redirect_stdout, redirect_stderr with redirect_stdout(console_stdout_redirect), \ redirect_stderr(console_errout_redirect): # run mw.print_info() sys.exit(app.exec_()) else: # run mw.print_info() sys.exit(app.exec_())
def load_font(self, prefix, ttf_filename, charmap_filename, directory=None): """Loads a font file and the associated charmap If `directory` is None, the files will be looked up in ./fonts/ Arguments --------- prefix: str prefix string to be used when accessing a given font set ttf_filename: str ttf font filename charmap_filename: str charmap filename directory: str or None, optional directory for font and charmap files """ def hook(obj): result = {} for key in obj: result[key] = unichr(int(obj[key], 16)) return result if directory is None: directory = os.path.join( os.path.dirname(os.path.realpath(__file__)), 'fonts') with open(os.path.join(directory, ttf_filename), 'rb') as f: font_data = QByteArray(f.read()) with open(os.path.join(directory, charmap_filename), 'r') as codes: self.charmap[prefix] = json.load(codes, object_hook=hook) id_ = QFontDatabase.addApplicationFontFromData(font_data) loadedFontFamilies = QFontDatabase.applicationFontFamilies(id_) if(loadedFontFamilies): self.fontname[prefix] = loadedFontFamilies[0] else: print('Font is empty')
def __init__(self, config: Config) -> None: """ Main window with the GUI and whatever player is being used. """ super().__init__() self.setWindowTitle('vidify') # Setting the window to stay on top if config.stay_on_top: self.setWindowFlags(Qt.WindowStaysOnTopHint) # Setting the fullscreen and window size if config.fullscreen: self.showFullScreen() else: self.setMinimumSize(800, 800) self.resize(config.width or 800, config.height or 800) # Loading the used fonts (Inter) font_db = QFontDatabase() for font in Res.fonts: font_db.addApplicationFont(font) # Initializing the player and saving the config object in the window. self.layout = QHBoxLayout(self) self.layout.setContentsMargins(0, 0, 0, 0) self.layout.setSpacing(0) self.config = config # Otherwise, the user is prompted for an API. After choosing one, # it will be initialized from outside this function. logging.info("Loading setup screen") self.setup_widget = SetupWidget(config.api, config.player) self.layout.addWidget(self.setup_widget) self.setup_widget.done.connect(self.on_setup_done) # Setting focus on the continue button after the first time. if None not in (config.api, config.player): self.setup_widget.continue_btn.setFocus()
def main(): app = QApplication(sys.argv) app.setWindowIcon(QIcon(':/icons/app.svg')) fontDB = QFontDatabase() fontDB.addApplicationFont(':/fonts/Roboto-Regular.ttf') app.setFont(QFont('Roboto')) f = QFile(':/style.qss') f.open(QFile.ReadOnly | QFile.Text) app.setStyleSheet(QTextStream(f).readAll()) f.close() translator = QTranslator() translator.load(':/translations/' + QLocale.system().name() + '.qm') app.installTranslator(translator) mw = MainWindow() mw.show() sys.exit(app.exec_())
def _init_pyqt(self, exp): global app, font_database # Add the Qt plugin folders to the library path, if they exists. Where # these folders are depends on the version of Qt4, but these are two # possible locations. qt_plugin_path = os.path.join(os.path.dirname(sys.executable), 'Library', 'plugins') if os.path.isdir(qt_plugin_path): QCoreApplication.addLibraryPath( safe_decode(qt_plugin_path, enc=misc.filesystem_encoding())) qt_plugin_path = os.path.join(os.path.dirname(sys.executable), 'Library', 'lib', 'qt4', 'plugins') if os.path.isdir(qt_plugin_path): QCoreApplication.addLibraryPath( safe_decode(qt_plugin_path, enc=misc.filesystem_encoding())) # If no instance of QApplication exists, a segmentation fault seems to always # occur. So we create one. if QCoreApplication.instance() is None: app = QApplication([]) # Register the fonts bundled with OpenSesame if font_database is None: font_database = QFontDatabase() for font in FONTS: try: path = exp.resource(font + u'.ttf') except: warnings.warn(u'Font %s not found' % font) continue font_id = font_database.addApplicationFont(path) if font_id < 0: warnings.warn(u'Failed to load font %s' % font) continue font_families = font_database.applicationFontFamilies(font_id) if not font_families: warnings.warn(u'Font %s contains no families' % font) continue font_substitutions.append((font_families[0], font))
def _init_font(self): # There isn't a standard way of getting the system default monospace # font in Qt4 (it was introduced in Qt5.2). If QFontDatabase.FixedFont # exists, then we can assume that this functionality exists and ask for # the correct font directly. Otherwise we ask for a font that doesn't # exist and specify our requirements. Qt then finds an existing font # that best matches our parameters. if hasattr(QFontDatabase, "systemFont") and hasattr( QFontDatabase, "FixedFont"): font = QFontDatabase.systemFont(QFontDatabase.FixedFont) else: font = QFont("") font.setFixedPitch(True) font.setStyleHint(QFont.Monospace) self.setFont(font)
def __init__(self, file_name, job_name, job_number, realization, iteration, parent=None): super().__init__(parent) self.setWindowTitle( f"{job_name} # {job_number} " f"Realization: {realization} Iteration: {iteration}") try: self._file = open(file_name, "r") except OSError as error: self._mb = QMessageBox( QMessageBox.Critical, "Error opening file", error.strerror, QMessageBox.Ok, self, ) self._mb.finished.connect(self.accept) self._mb.show() return self._view = QPlainTextEdit() self._view.setReadOnly(True) self._view.setWordWrapMode(QTextOption.NoWrap) # for moving the actual slider self._view.verticalScrollBar().sliderMoved.connect(self._update_cursor) # for mouse wheel and keyboard arrows self._view.verticalScrollBar().valueChanged.connect( self._update_cursor) self._view.setFont(QFontDatabase.systemFont(QFontDatabase.FixedFont)) self._follow_mode = False self._init_layout() self._init_thread() self.show()
from qtpy.QtCore import Slot, QRegExp from qtpy.QtGui import QFontDatabase, QRegExpValidator from qtpy.QtWidgets import QAbstractButton from qtpyvcp import actions from qtpyvcp.utilities import logger from qtpyvcp.widgets.form_widgets.main_window import VCPMainWindow import probe_basic_rc LOG = logger.getLogger('QtPyVCP.' + __name__) VCP_DIR = os.path.abspath(os.path.dirname(__file__)) # Add custom fonts QFontDatabase.addApplicationFont(os.path.join(VCP_DIR, 'fonts/BebasKai.ttf')) class ProbeBasic(VCPMainWindow): """Main window class for the ProbeBasic VCP.""" def __init__(self, *args, **kwargs): super(ProbeBasic, self).__init__(*args, **kwargs) self.run_from_line_Num.setValidator(QRegExpValidator(QRegExp("[0-9]*"))) self.dynatc_left.iniFilePrefix = "LEFT_" self.dynatc_right.iniFilePrefix = "RIGHT_" @Slot(QAbstractButton) def on_probetabGroup_buttonClicked(self, button): self.probe_tab_widget.setCurrentIndex(button.property('page')) @Slot(QAbstractButton) def on_guiaxisdisplayGroup_buttonClicked(self, button):
def __init__(self, port: str = None, baudrate: int = None, address: int = None): super().__init__() # # Main window UI # logging.debug("Initializing MainWindow from mainwindow.ui") self.ui = loadUi(dirname(__file__) + "/mainwindow.ui", self) logging.debug("Configuring fixed font for labels") font = QFontDatabase.systemFont(QFontDatabase.FixedFont) font.setBold(True) font.setPointSize(36) self.ui.voltageInput.setFont(font) self.ui.voltageOutput.setFont(font) self.ui.currentOutput.setFont(font) self.ui.powerOutput.setFont(font) logging.debug("Resizing widgets and window to minimum size") self.adjustSize() self.resize(self.minimumSize()) # # Default value definitions # # Precition output formats # Display formats on real devices # Model V I P-on<99W P-on>99W # RD6006P 00.000 0.0000 00.000 000.00 # RD6006 00.00 0.000 00.00 000.0 # RD6012 00.00 00.00 00.00 000.0 # RD6018 00.00 00.00 00.00 000.0 logging.debug("Defining default value definitions") self.default_voltage_input_format = "%05.2f" self.default_voltage_output_format = "%05.2f" self.default_current_output_format = "%05.2f" self.default_power_output_format = "%6.2f" self.default_voltage_max = 61.0 self.default_current_max = 0.0 # # QSettings & Setting variables # logging.debug("Initializing QSettings") self.settings = QSettings("ShayBox", "RidenGUI") if self.settings.value("first-run", 1) == 1: logging.debug("First run detected, showing settings wizard") SettingsWizard(self.settings, self).exec() exit(0) logging.debug("Loading custom format strings from settings") self.voltage_input_format = self.settings.value( "format/voltage-input", self.default_voltage_input_format) self.voltage_output_format = self.settings.value( "format/voltage-output", self.default_voltage_output_format) self.current_output_format = self.settings.value( "format/current-output", self.default_current_output_format) self.power_output_format = self.settings.value( "format/power-output", self.default_power_output_format) logging.debug("Loading custom stylesheets from settings") self.output_on = self.settings.value( "style/output-on-bg") + self.settings.value("style/output-on-text") self.output_off = self.settings.value( "style/output-off-bg") + self.settings.value( "style/output-off-text") self.output_fault = self.settings.value( "style/output-fault-bg") + self.settings.value( "style/output-fault-text") # # Riden # logging.debug("Initializing Riden library") self.r = Riden( port=port or self.settings.value("serial/port", "/dev/ttyUSB0"), baudrate=baudrate or int(self.settings.value("serial/baudrate", 115200)), address=address or int(self.settings.value("serial/address", 1)), ) logging.debug("Defining temporary variables for live feedback") self.prev_v_set = self.r.v_set self.prev_i_set = self.r.i_set # # Dynamic value definitions # logging.debug("Defining dynamic value definitions") if self.r.type == "RD6012": self.default_voltage_output_format = "%05.3f" self.default_current_output_format = "%05.4f" self.default_power_output_format = "%6.3f" self.default_current_max = 6.1 elif self.r.type == "RD6006": self.default_current_output_format = "%04.3f" self.default_current_max = 6.1 elif self.r.type == "RD6012": self.default_current_max = 12.1 elif self.r.type == "RD6018": self.default_current_max = 18.1 elif self.r.type == "RD6024": self.default_current_max = 24.1 # # Qt Slots, Signals, and Messages # logging.debug("Connecting signals and slots") self.connect_signals() logging.debug("Setting permenant statusbar message") self.ui.statusbar.showMessage( "Connected to %s using %s at %s baud | FW: %s | SN: %s" % ( self.r.type, self.r.serial.port, self.r.serial.baudrate, self.r.fw, self.r.sn, )) # # Background worker # logging.debug("Starting worker thread") self.worker = Worker(self.r, self.settings, self) self.worker.update.connect(self.worker_signal) self.worker.start()
def main(): if len(sys.argv) > 1 and sys.argv[1] == "_test": _test_imports() return parser = CustomParser("PartSeg") parser.add_argument( "--multiprocessing-fork", dest="mf", action="store_true", help=argparse.SUPPRESS ) # Windows bug fix sp = parser.add_subparsers() sp_a = sp.add_parser("roi_analysis", help="Starts GUI for segmentation analysis") sp_s = sp.add_parser("mask_segmentation", help="Starts GUI for segmentation") parser.set_defaults(gui="launcher") sp_a.set_defaults(gui="roi_analysis") sp_s.set_defaults(gui="roi_mask") sp_a.add_argument("image", nargs="?", help="image to read on begin", default="") sp_a.add_argument("mask", nargs="?", help="mask to read on begin", default=None) sp_a.add_argument("--batch", action="store_true", help=argparse.SUPPRESS) sp_s.add_argument("image", nargs="?", help="image to read on begin", default="") argv = [x for x in sys.argv[1:] if not (x.startswith("parent") or x.startswith("pipe"))] args = parser.parse_args(argv) # print(args) logging.basicConfig(level=logging.INFO) CustomApplication.setAttribute(Qt.AA_EnableHighDpiScaling) my_app = CustomApplication(sys.argv, name="PartSeg", icon=os.path.join(icons_dir, "icon.png")) my_app.check_release() my_app.aboutToQuit.connect(wait_for_workers_to_quit) QFontDatabase.addApplicationFont(os.path.join(font_dir, "Symbola.ttf")) if args.gui == "roi_analysis" or args.mf: from PartSeg import plugins plugins.register() from PartSeg._roi_analysis.main_window import MainWindow title = f"{APP_NAME} {ANALYSIS_NAME}" if args.image: image = TiffImageReader.read_image(args.image, args.mask) MainWindow = partial(MainWindow, initial_image=image) wind = MainWindow(title=title) if args.batch: wind.main_menu.batch_window() elif args.gui == "roi_mask": from PartSeg import plugins plugins.register() from PartSeg._roi_mask.main_window import MainWindow title = f"{APP_NAME} {MASK_NAME}" if args.image: image = TiffImageReader.read_image(args.image) MainWindow = partial(MainWindow, initial_image=image) wind = MainWindow(title=title) else: from PartSeg._launcher.main_window import MainWindow title = f"{APP_NAME} Launcher" wind = MainWindow(title=title) wind.show() rc = my_app.exec_() del wind del my_app sys.exit(rc)
def load_font(self, prefix, ttf_filename, charmap_filename, directory=None): """Loads a font file and the associated charmap. If ``directory`` is None, the files will be looked for in ``./fonts/``. Parameters ---------- prefix: str Prefix string to be used when accessing a given font set ttf_filename: str Ttf font filename charmap_filename: str Charmap filename directory: str or None, optional Directory for font and charmap files """ def hook(obj): result = {} for key in obj: result[key] = unichr(int(obj[key], 16)) return result if directory is None: directory = os.path.join( os.path.dirname(os.path.realpath(__file__)), 'fonts') # Load font if QApplication.instance() is not None: id_ = QFontDatabase.addApplicationFont( os.path.join(directory, ttf_filename)) loadedFontFamilies = QFontDatabase.applicationFontFamilies(id_) if (loadedFontFamilies): self.fontname[prefix] = loadedFontFamilies[0] else: raise FontError(u"Font at '{0}' appears to be empty. " "If you are on Windows 10, please read " "https://support.microsoft.com/" "en-us/kb/3053676 " "to know how to prevent Windows from blocking " "the fonts that come with QtAwesome.".format( os.path.join(directory, ttf_filename))) with open(os.path.join(directory, charmap_filename), 'r') as codes: self.charmap[prefix] = json.load(codes, object_hook=hook) # Verify that vendorized fonts are not corrupt if not SYSTEM_FONTS: md5_hashes = { 'fontawesome4.7-webfont.ttf': 'b06871f281fee6b241d60582ae9369b9', 'fontawesome5-regular-webfont.ttf': '73fe7f1effbf382f499831a0a9f18626', 'fontawesome5-solid-webfont.ttf': '0079a0ab6bec4da7d6e16f2a2e87cd71', 'fontawesome5-brands-webfont.ttf': '947b9537bc0fecc8130d48eb753495a1', 'elusiveicons-webfont.ttf': '207966b04c032d5b873fd595a211582e', 'materialdesignicons-webfont.ttf': '64b96825d49e070ea87c7100f2db3f46' } ttf_hash = md5_hashes.get(ttf_filename, None) if ttf_hash is not None: hasher = hashlib.md5() with open(os.path.join(directory, ttf_filename), 'rb') as f: content = f.read() hasher.update(content) ttf_calculated_hash_code = hasher.hexdigest() if ttf_calculated_hash_code != ttf_hash: raise FontError(u"Font is corrupt at: '{0}'".format( os.path.join(directory, ttf_filename)))
def load_fonts(app): """Load custom fonts.""" app.database = QFontDatabase() for font in FONTFILES: app.database.addApplicationFont(font)
def load_font(self, prefix, ttf_filename, charmap_filename, directory=None): """Loads a font file and the associated charmap. If ``directory`` is None, the files will be looked for in the qtawesome ``fonts`` directory. Parameters ---------- prefix: str Prefix string to be used when accessing a given font set ttf_filename: str Ttf font filename charmap_filename: str Charmap filename directory: str or None, optional Directory path for font and charmap files """ def hook(obj): result = {} for key in obj: try: result[key] = chr(int(obj[key], 16)) except ValueError: if int(obj[key], 16) > 0xffff: # ignoring unsupported code in Python 2.7 32bit Windows # ValueError: chr() arg not in range(0x10000) pass else: raise FontError(u'Failed to load character ' '{0}:{1}'.format(key, obj[key])) return result if directory is None: directory = os.path.join( os.path.dirname(os.path.realpath(__file__)), 'fonts') # Load font if QApplication.instance() is not None: with open(os.path.join(directory, ttf_filename), 'rb') as font_data: id_ = QFontDatabase.addApplicationFontFromData( QByteArray(font_data.read())) font_data.close() loadedFontFamilies = QFontDatabase.applicationFontFamilies(id_) if loadedFontFamilies: self.fontids[prefix] = id_ self.fontname[prefix] = loadedFontFamilies[0] else: raise FontError(u"Font at '{0}' appears to be empty. " "If you are on Windows 10, please read " "https://support.microsoft.com/" "en-us/kb/3053676 " "to know how to prevent Windows from blocking " "the fonts that come with QtAwesome.".format( os.path.join(directory, ttf_filename))) with open(os.path.join(directory, charmap_filename), 'r') as codes: self.charmap[prefix] = json.load(codes, object_hook=hook)
def load_font(self, prefix, ttf_filename, charmap_filename, directory=None): """Loads a font file and the associated charmap. If ``directory`` is None, the files will be looked for in ``./fonts/``. Parameters ---------- prefix: str Prefix string to be used when accessing a given font set ttf_filename: str Ttf font filename charmap_filename: str Charmap filename directory: str or None, optional Directory for font and charmap files """ def hook(obj): result = {} for key in obj: result[key] = unichr(int(obj[key], 16)) return result if directory is None: directory = os.path.join( os.path.dirname(os.path.realpath(__file__)), 'fonts') # Load font if QApplication.instance() is not None: id_ = QFontDatabase.addApplicationFont( os.path.join(directory, ttf_filename)) loadedFontFamilies = QFontDatabase.applicationFontFamilies(id_) if (loadedFontFamilies): self.fontname[prefix] = loadedFontFamilies[0] else: raise FontError(u"Font at '{0}' appears to be empty. " "If you are on Windows 10, please read " "https://support.microsoft.com/" "en-us/kb/3053676 " "to know how to prevent Windows from blocking " "the fonts that come with QtAwesome.".format( os.path.join(directory, ttf_filename))) with open(os.path.join(directory, charmap_filename), 'r') as codes: self.charmap[prefix] = json.load(codes, object_hook=hook) # Verify that vendorized fonts are not corrupt if not SYSTEM_FONTS: md5_hashes = { 'fontawesome4.7-webfont.ttf': 'b06871f281fee6b241d60582ae9369b9', 'fontawesome5-regular-webfont.ttf': '0e2e26fb3527ae47f9eb1c217592b706', 'fontawesome5-solid-webfont.ttf': 'e143b57de78138e6d5963908afa7e393', 'fontawesome5-brands-webfont.ttf': 'dec02372212aab5a2e5294f1a11756ed', 'elusiveicons-webfont.ttf': '207966b04c032d5b873fd595a211582e', 'materialdesignicons-webfont.ttf': '023db9122f66b7d693bc52bcdf09e6b3' } ttf_hash = md5_hashes.get(ttf_filename, None) if ttf_hash is not None: hasher = hashlib.md5() with open(os.path.join(directory, ttf_filename), 'rb') as f: content = f.read() hasher.update(content) ttf_calculated_hash_code = hasher.hexdigest() if ttf_calculated_hash_code != ttf_hash: raise FontError(u"Font is corrupt at: '{0}'".format( os.path.join(directory, ttf_filename)))
def load_font(self, prefix, ttf_filename, charmap_filename, directory=None): """Loads a font file and the associated charmap. If ``directory`` is None, the files will be looked for in ``./fonts/``. Parameters ---------- prefix: str Prefix string to be used when accessing a given font set ttf_filename: str Ttf font filename charmap_filename: str Charmap filename directory: str or None, optional Directory for font and charmap files """ def hook(obj): result = {} for key in obj: try: result[key] = chr(int(obj[key], 16)) except ValueError: if int(obj[key], 16) > 0xffff: # ignoring unsupported code in Python 2.7 32bit Windows # ValueError: chr() arg not in range(0x10000) warnings.warn("Your Python version doesn't support " "character {0}:{1}".format( key, obj[key])) else: raise FontError(u'Failed to load character ' '{0}:{1}'.format(key, obj[key])) return result if directory is None: directory = os.path.join( os.path.dirname(os.path.realpath(__file__)), 'fonts') # Load font if QApplication.instance() is not None: with open(os.path.join(directory, ttf_filename), 'rb') as font_data: id_ = QFontDatabase.addApplicationFontFromData( QByteArray(font_data.read())) font_data.close() loadedFontFamilies = QFontDatabase.applicationFontFamilies(id_) if loadedFontFamilies: self.fontname[prefix] = loadedFontFamilies[0] else: raise FontError(u"Font at '{0}' appears to be empty. " "If you are on Windows 10, please read " "https://support.microsoft.com/" "en-us/kb/3053676 " "to know how to prevent Windows from blocking " "the fonts that come with QtAwesome.".format( os.path.join(directory, ttf_filename))) with open(os.path.join(directory, charmap_filename), 'r') as codes: self.charmap[prefix] = json.load(codes, object_hook=hook) # Verify that vendorized fonts are not corrupt if not SYSTEM_FONTS: ttf_hash = MD5_HASHES.get(ttf_filename, None) if ttf_hash is not None: hasher = hashlib.md5() with open(os.path.join(directory, ttf_filename), 'rb') as f: content = f.read() hasher.update(content) ttf_calculated_hash_code = hasher.hexdigest() if ttf_calculated_hash_code != ttf_hash: raise FontError(u"Font is corrupt at: '{0}'".format( os.path.join(directory, ttf_filename)))
def load_font(self, prefix, ttf_filename, charmap_filename, directory=None): """Loads a font file and the associated charmap. If ``directory`` is None, the files will be looked for in ``./fonts/``. Parameters ---------- prefix: str Prefix string to be used when accessing a given font set ttf_filename: str Ttf font filename charmap_filename: str Charmap filename directory: str or None, optional Directory for font and charmap files """ def hook(obj): result = {} for key in obj: result[key] = unichr(int(obj[key], 16)) return result if directory is None: directory = os.path.join( os.path.dirname(os.path.realpath(__file__)), 'fonts') # Load font if QApplication.instance() is not None: id_ = QFontDatabase.addApplicationFont( os.path.join(directory, ttf_filename)) loadedFontFamilies = QFontDatabase.applicationFontFamilies(id_) if (loadedFontFamilies): self.fontname[prefix] = loadedFontFamilies[0] else: raise FontError(u"Font at '{0}' appears to be empty. " "If you are on Windows 10, please read " "https://support.microsoft.com/" "en-us/kb/3053676 " "to know how to prevent Windows from blocking " "the fonts that come with QtAwesome.".format( os.path.join(directory, ttf_filename))) with open(os.path.join(directory, charmap_filename), 'r') as codes: self.charmap[prefix] = json.load(codes, object_hook=hook) # Verify that vendorized fonts are not corrupt if not SYSTEM_FONTS: md5_hashes = { 'fontawesome-webfont.ttf': 'a3de2170e4e9df77161ea5d3f31b2668', 'elusiveicons-webfont.ttf': '207966b04c032d5b873fd595a211582e' } ttf_hash = md5_hashes.get(ttf_filename, None) if ttf_hash is not None: hasher = hashlib.md5() with open(os.path.join(directory, ttf_filename), 'rb') as f: content = f.read() hasher.update(content) ttf_calculated_hash_code = hasher.hexdigest() if ttf_calculated_hash_code != ttf_hash: raise FontError(u"Font is corrupt at: '{0}'".format( os.path.join(directory, ttf_filename)))
def font_is_installed(font): """Check if font is installed""" return [fam for fam in QFontDatabase().families() if to_text_string(fam)==font]
def __init__(self, filetype, filename): super().__init__() from db.BiblesSqlite import Bible self.fontDatabase = QFontDatabase() self.filetype = filetype self.filename = filename self.setWindowTitle(config.thisTranslation["modify_database"]) self.layout = QVBoxLayout() self.setMinimumWidth(300) if filetype == "bible": self.bible = Bible(filename) self.bible.addMissingColumns() (fontName, fontSize, css) = self.bible.getFontInfo() if fontName is None: fontName = "" if fontSize is None: fontSize = "" self.layout.addWidget( QLabel("{0}: {1}".format(config.thisTranslation["name"], filename))) row = QHBoxLayout() row.addWidget( QLabel("{0}: ".format(config.thisTranslation["title"]))) self.bibleTitle = QLineEdit() self.bibleTitle.setText(self.bible.bibleInfo()) self.bibleTitle.setMaxLength(100) row.addWidget(self.bibleTitle) self.layout.addLayout(row) grid = QGridLayout() self.builtinFonts = [""] + self.fontDatabase.families() try: index = self.builtinFonts.index( fontName.replace(".builtin", "")) except: index = 0 self.useBuiltinFont = QRadioButton() self.useBuiltinFont.clicked.connect( lambda: self.selectRadio("builtin")) grid.addWidget(self.useBuiltinFont, 0, 0) grid.addWidget(QLabel("{0}: ".format("Built-in font")), 0, 1) self.builtinFontList = QComboBox() self.builtinFontList.addItems(self.builtinFonts) self.builtinFontList.setCurrentIndex(index) grid.addWidget(self.builtinFontList, 0, 2) fonts = sorted(glob.glob(r"htmlResources/fonts/*.*")) self.fontFiles = [''] + [os.path.basename(font) for font in fonts] try: index = self.fontFiles.index(fontName) except: index = 0 row = QHBoxLayout() self.useFileFont = QRadioButton() self.useFileFont.clicked.connect(lambda: self.selectRadio("file")) grid.addWidget(self.useFileFont, 1, 0) row.addStretch(1) grid.addWidget(QLabel("{0}: ".format("Font file")), 1, 1) self.fileFontList = QComboBox() self.fileFontList.addItems(self.fontFiles) self.fileFontList.setCurrentIndex(index) grid.addWidget(self.fileFontList, 1, 2) self.layout.addLayout(grid) else: self.layout.addWidget( QLabel("{0} is not supported".format(filetype))) row = QHBoxLayout() row.addWidget( QLabel("{0}: ".format(config.thisTranslation["menu2_fontSize"]))) self.fontSize = QLineEdit() self.fontSize.setText(fontSize) self.fontSize.setMaxLength(20) row.addWidget(self.fontSize) self.layout.addLayout(row) self.languageCodes = ["" ] + [value for value in Languages.code.values()] row = QHBoxLayout() row.addWidget( QLabel("{0}: ".format(config.thisTranslation["menu_language"]))) self.languageList = QComboBox() row.addWidget(self.languageList) self.languageList.addItems(self.languageCodes) self.languageList.setCurrentIndex( self.languageCodes.index(self.bible.getLanguage())) self.layout.addLayout(row) buttons = QDialogButtonBox.Ok | QDialogButtonBox.Cancel self.buttonBox = QDialogButtonBox(buttons) self.buttonBox.accepted.connect(self.save) self.buttonBox.accepted.connect(self.accept) self.buttonBox.rejected.connect(self.reject) self.layout.addWidget(self.buttonBox) self.setLayout(self.layout) if ".ttf" in fontName: self.selectRadio("file") else: self.selectRadio("builtin")