示例#1
0
def show_writing_to_pronunciation_dialog(text, callback):
    dialog = EphemeralDialog()
    possible_fonts = qg.QFontDatabase().families(qg.QFontDatabase.Japanese)
    japanese_fonts = [font for font in possible_fonts if 'jp' in font.lower()]
    font = qg.QFont(japanese_fonts[0])
    dialog.setFont(font)
    big_font = qg.QFont(font)
    big_font.setPointSize(font.pointSize() * 1.5)
    dialog.text = qw.QLabel(text.replace('\t', ''))
    dialog.text.setFont(big_font)
    dialog.text.setTextInteractionFlags(qc.Qt.TextSelectableByMouse)
    dialog.pronunciation_button = qw.QPushButton('Check pronunciation')
    dialog.pronunciation_button.setDefault(True)

    def check():
        dialog.accept()
        callback()

    dialog.pronunciation_button.clicked.connect(check)

    vlayout = qw.QVBoxLayout()
    vlayout.addWidget(dialog.text)
    vlayout.addWidget(dialog.pronunciation_button)
    dialog.setLayout(vlayout)

    dialog.show()

    return dialog
示例#2
0
    def __init__(self, **kwargs):
        super(Window, self).__init__(objectName='window', **kwargs)

        self.setContentsMargins(50, 75, 50, 50)

        self.setStyleSheet('#window {{ background-color: {}; }}'.format(
            settings.intervention['background-color']))

        fonts = QtGui.QFontDatabase()

        # There's no way to specify the proper font style in CSS
        self.text_font = fonts.font('Museo Slab', '500', 36)
        self.status_font = fonts.font('Museo Slab', '500', 82)
        self.title_font = fonts.font('Museo Slab', '500', 96)

        message = Message(parent=self, font=self.title_font)
        self.inputs = Inputs(parent=self, font=self.text_font)

        self.layout = QtWidgets.QVBoxLayout()

        self.layout.addWidget(message)
        self.layout.addSpacing(40)
        self.layout.addWidget(self.inputs)
        self.layout.addStretch(1)

        self.setLayout(self.layout)
示例#3
0
def load_mono_font():
    """
    Load the monospaced font and set the module-global :data:`_MONO_FONT` object.

    .. note::

        Must be called after :class:`PySide2.QtWidgets.QApplication` is instantiated!

    """
    try:
        # first try to load fira code for monospace font
        external_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)),
                                    'external')
        font_db = QtGui.QFontDatabase()
        font_db.addApplicationFont(
            os.path.join(external_dir, 'FiraCode-Regular.otf'))
        font_db.addApplicationFont(
            os.path.join(external_dir, 'FiraCode-Bold.otf'))
        mono_font = QtGui.QFont('Fira Code')
    except:  # pragma: no cover
        # if that fails, try to load liberation mono
        # TODO: Log this
        try:
            mono_font = QtGui.QFont('Liberation Mono')

        except:
            # otherwise get the system default mono font
            mono_font = QtGui.QFont()
            mono_font.setStyleHint(QtGui.QFont.Monospace)

    globals()['_MONO_FONT'] = mono_font
示例#4
0
        def mouseMoveEvent(self, event):
            x = event.x()
            y = event.y()
            H = self._pixmap_size.height()
            W = self._pixmap_size.width()
            X0 = self._margin_size.width()
            Y0 = self._margin_size.height()
            Htot = (2 * self._margin_size + self._pixmap_size).height()
            Wtot = (2 * self._margin_size + self._pixmap_size).width()

            sz = self.size()
            h = sz.height()
            w = sz.width()

            X = int(round(x * Wtot / w))
            Y = int(round(y * Htot / h))

            if X < X0: return
            if X > X0 + W: return
            if Y < Y0: return
            if Y > Y0 + H: return

            pixmap = qtgui.QPixmap(self._pixmap_size + 2 * self._margin_size)
            pixmap.fill(qtcore.Qt.transparent)

            painter = qtgui.QPainter()
            painter.begin(pixmap)

            pen = qtgui.QPen()
            pen.setWidth(5)
            pen.setCapStyle(qtcore.Qt.RoundCap)
            pen.setJoinStyle(qtcore.Qt.RoundJoin)

            font = self.font()
            font_db = qtgui.QFontDatabase()
            sz = font.pointSize()
            SZ = int(round(sz * Htot / h))
            font = font_db.font(font.family(), font.styleName(), SZ)

            painter.setFont(font)

            color = qtgui.QColor(0, 0, 255, 255)
            pen.setColor(color)
            painter.setPen(pen)

            for x, y in self._marks:
                self._draw_mark(painter, x, y, X0, Y0, H, W, SZ)

            color = qtgui.QColor(255, 0, 0, 255)
            pen.setColor(color)
            painter.setPen(pen)
            self._draw_mark(painter, X, Y, X0, Y0, H, W, SZ, back=False)
            painter.end()
            self.setPixmap(pixmap)
 def updateStyle(self, fontStyle):
     fontDatabase = QtGui.QFontDatabase()
     oldStrategy = self.displayFont.styleStrategy()
     self.displayFont = fontDatabase.font(self.displayFont.family(),
                                          fontStyle,
                                          self.displayFont.pointSize())
     self.displayFont.setStyleStrategy(oldStrategy)
     self.squareSize = max(
         24,
         QtGui.QFontMetrics(self.displayFont).xHeight() * 3)
     self.adjustSize()
     self.update()
    def findStyles(self, font):
        fontDatabase = QtGui.QFontDatabase()
        currentItem = self.styleCombo.currentText()
        self.styleCombo.clear()

        for style in fontDatabase.styles(font.family()):
            self.styleCombo.addItem(style)

        styleIndex = self.styleCombo.findText(currentItem)
        if styleIndex == -1:
            self.styleCombo.setCurrentIndex(0)
        else:
            self.styleCombo.setCurrentIndex(styleIndex)
示例#7
0
def showWindow(settings):
    fonts = [
    ":/fonts/fonts/WorkSans-Light.ttf",
    ":/fonts/fonts/WorkSans-Medium.ttf",
    ":/fonts/fonts/WorkSans-Regular.ttf",
    ":/fonts/fonts/WorkSans-SemiBold.ttf"
    ]
    for font in fonts:
        if font not in QtGui.QFontDatabase().families():
            QtGui.QFontDatabase.addApplicationFont(font)

    win = gfMayaWidgets.showMayaWidget(MainWin, data=settings)
    return win
示例#8
0
    def _create_color_text_label(self):
        self._color_text_label = QtWidgets.QLabel()
        self._color_text_label.setFixedHeight(14)
        self._color_text_label.setAlignment(QtCore.Qt.AlignLeft)
        font_id = QtGui.QFontDatabase().addApplicationFont(APP.FONT_FILE_PATH)
        if font_id == -1:
            error_msg = f'Could not load font from {APP.FONT_FILE_PATH}'
            raise RuntimeError(error_msg)
        font = QtGui.QFont(APP.FONT_FAMILY)
        font.setPointSize(12)
        self._color_text_label.setFont(font)

        return self._color_text_label
示例#9
0
def show_pronunciation_to_writing_dialog(pronunciation, audio_file, callback):
    dialog = EphemeralDialog()
    possible_fonts = qg.QFontDatabase().families(qg.QFontDatabase.Japanese)
    japanese_fonts = [font for font in possible_fonts if 'jp' in font.lower()]
    font = qg.QFont(japanese_fonts[0])
    dialog.setFont(font)
    big_font = qg.QFont(font)
    big_font.setPointSize(font.pointSize() * 1.5)
    dialog.pronunciation = qw.QLabel(pronunciation.replace('\t', ''))
    dialog.pronunciation.setFont(big_font)
    dialog.pronunciation.setTextInteractionFlags(qc.Qt.TextSelectableByMouse)
    dialog.writing_button = qw.QPushButton('Check writing')
    dialog.writing_button.setDefault(True)

    def check():
        dialog.media_player.stop()
        dialog.accept()
        callback()

    dialog.writing_button.clicked.connect(check)

    vlayout = qw.QVBoxLayout()
    vlayout.addWidget(dialog.pronunciation)
    vlayout.addWidget(dialog.writing_button)
    dialog.setLayout(vlayout)

    dialog.playlist = qm.QMediaPlaylist()
    dialog.playlist.addMedia(qc.QUrl.fromLocalFile(
        os.path.abspath(audio_file)))
    dialog.playlist.setPlaybackMode(qm.QMediaPlaylist.Loop)
    dialog.media_player = qm.QMediaPlayer()
    dialog.media_player.setPlaylist(dialog.playlist)
    dialog.media_player.play()

    dialog.show()

    return dialog
示例#10
0
    def findSizes(self, font):
        fontDatabase = QtGui.QFontDatabase()
        currentSize = self.sizeCombo.currentText()
        self.sizeCombo.blockSignals(True)
        self.sizeCombo.clear()

        if fontDatabase.isSmoothlyScalable(font.family(),
                                           fontDatabase.styleString(font)):
            for size in QtGui.QFontDatabase.standardSizes():
                self.sizeCombo.addItem(str(size))
                self.sizeCombo.setEditable(True)
        else:
            for size in fontDatabase.smoothSizes(
                    font.family(), fontDatabase.styleString(font)):
                self.sizeCombo.addItem(str(size))
                self.sizeCombo.setEditable(False)

        self.sizeCombo.blockSignals(False)

        sizeIndex = self.sizeCombo.findText(currentSize)
        if sizeIndex == -1:
            self.sizeCombo.setCurrentIndex(max(0, self.sizeCombo.count() / 3))
        else:
            self.sizeCombo.setCurrentIndex(sizeIndex)
示例#11
0
 def _font(self, family, style, size):
     font_db = qtgui.QFontDatabase()
     family = "Font Awesome 5 " + family
     font = font_db.font(family, style, size)
     return font
示例#12
0
 def awesome_font(self, family="Free", style="Solid", size=12):
     font_db = qtgui.QFontDatabase()
     family = "Font Awesome 5 " + family
     font = font_db.font(family, style, size)
     return font
示例#13
0
def show_sentence_detail_dialog(text, pronunciation, translation, source_url,
                                creator, license_url, lemmas, grammars,
                                graphemes, forward_pronunciations,
                                backward_pronunciations, sounds, audio_file,
                                callback):
    def position_in(text):
        def position_in_text(detail):
            if isinstance(text, tuple):
                return tuple(
                    position_in(t)(d) for t, d in zip(text, detail[1:]))
            try:
                return text.index(detail)
            except ValueError:
                return len(text)

        return position_in_text

    lemmas = sorted(lemmas, key=position_in((text, )))
    graphemes = sorted(graphemes, key=position_in((text, )))
    forward_pronunciations = sorted(forward_pronunciations,
                                    key=position_in((text, pronunciation)))
    backward_pronunciations = sorted(backward_pronunciations,
                                     key=position_in((text, pronunciation)))
    sounds = sorted(sounds, key=position_in((pronunciation, )))
    dialog = EphemeralDialog()
    possible_fonts = qg.QFontDatabase().families(qg.QFontDatabase.Japanese)
    japanese_fonts = [font for font in possible_fonts if 'jp' in font.lower()]
    font = qg.QFont(japanese_fonts[0])
    dialog.setFont(font)
    big_font = qg.QFont(font)
    big_font.setPointSize(font.pointSize() * 1.5)
    rows = (row.split('\t') for row in (text, pronunciation))
    dialog.text_pronunciation_table = qw.QLabel(f'''<table><tr>{
            '</tr/><tr>'.join(
                ''.join(f'<td>{part}</td>' for part in row)
                for row in rows)
                }</tr></table>''')
    dialog.text_pronunciation_table.setFont(big_font)
    dialog.text_pronunciation_table.setTextInteractionFlags(
        qc.Qt.TextSelectableByMouse)
    dialog.translation = qw.QLabel(translation)
    dialog.translation.setFont(big_font)
    dialog.translation.setTextInteractionFlags(qc.Qt.TextSelectableByMouse)
    dialog.attribution = qw.QLabel(
        f'Example from <a href="{source_url}">{urllib.parse.unquote(source_url)}</a> '
        f'by {creator}, '
        f'licensed under <a href="{license_url}">{urllib.parse.unquote(license_url)}</a>'
    )
    dialog.attribution.setOpenExternalLinks(True)
    dialog.learn_button = qw.QPushButton('Learn')
    dialog.learn_button.setDefault(True)

    hlayout = qw.QHBoxLayout()
    lemma_checkboxes = []
    grammar_checkboxes = []
    grapheme_checkboxes = []
    forward_pronunciation_checkboxes = []
    backward_pronunciation_checkboxes = []
    sound_checkboxes = []

    def lemma_template(lemma, disambiguator, gloss):
        text = 'the meaning of %s (%s)' % (lemma, disambiguator)
        movie = None
        tooltip = gloss
        return text, movie, tooltip

    def writing_template(grapheme):
        relative_path = f'data/kanjivg/kanji/{ord(grapheme):05x}.gif'
        gif_path = os.path.join(os.path.dirname(__file__), relative_path)
        text = 'writing '
        movie = os.path.abspath(gif_path)
        tooltip = grapheme
        return text, movie, tooltip

    def format_template(template):
        return lambda *args: (template.format(*args), None, None)

    for memory_items, checkboxes, template in (
        (lemmas, lemma_checkboxes,
         lemma_template), (grammars, grammar_checkboxes,
                           format_template('the form {}')),
        (graphemes, grapheme_checkboxes, writing_template),
        (forward_pronunciations, forward_pronunciation_checkboxes,
         format_template('{} pronounced as {}')),
        (backward_pronunciations, backward_pronunciation_checkboxes,
         format_template('{1} written as {0}')),
        (sounds, sound_checkboxes, format_template('pronouncing {}'))):
        if not memory_items:
            continue
        vlayout = qw.QVBoxLayout()
        for item in memory_items:
            boxlabel, movie, tooltip = template(*item[1:])
            checkbox = qw.QCheckBox(boxlabel)
            checkbox.setCheckState(qc.Qt.CheckState.Checked)
            if tooltip:
                checkbox.setToolTip(tooltip)
            checkboxes.append(checkbox)
            if movie:
                boxlayout = qw.QHBoxLayout()
                label = MovieLabel(movie,
                                   size=qc.QSize(font.pointSize() * 2,
                                                 font.pointSize() * 2),
                                   hover_size=qc.QSize(-1, -1))
                boxlayout.addWidget(checkbox)
                boxlayout.addWidget(label)
                vlayout.addLayout(boxlayout)
            else:
                vlayout.addWidget(checkbox)
        scrollframe = VerticalScrollFrame()
        scrollframe.setLayout(vlayout)
        hlayout.addWidget(scrollframe.scrollarea)

    def learn():
        dialog.media_player.stop()
        dialog.accept()
        callback(
            **{
                table + '_selection': [(item[0], checkbox.isChecked())
                                       for item, checkbox in zip(
                                           memory_items, checkboxes)]
                for table, memory_items, checkboxes in (
                    ('lemma', lemmas, lemma_checkboxes), ('grammar', grammars,
                                                          grammar_checkboxes),
                    ('grapheme', graphemes, grapheme_checkboxes),
                    ('forward_pronunciation', forward_pronunciations,
                     forward_pronunciation_checkboxes),
                    ('backward_pronunciation', backward_pronunciations,
                     backward_pronunciation_checkboxes), ('sound', sounds,
                                                          sound_checkboxes))
            })

    dialog.learn_button.clicked.connect(learn)

    vlayout = qw.QVBoxLayout()
    vlayout.addWidget(dialog.text_pronunciation_table)
    vlayout.addWidget(dialog.translation)
    vlayout.addLayout(hlayout)
    vlayout.addWidget(dialog.attribution)
    vlayout.addWidget(dialog.learn_button)
    dialog.setLayout(vlayout)

    dialog.playlist = qm.QMediaPlaylist()
    dialog.playlist.addMedia(qc.QUrl.fromLocalFile(
        os.path.abspath(audio_file)))
    dialog.playlist.setPlaybackMode(qm.QMediaPlaylist.Loop)
    dialog.media_player = qm.QMediaPlayer()
    dialog.media_player.setPlaylist(dialog.playlist)
    dialog.media_player.play()

    dialog.show()

    return dialog
示例#14
0
    def initialize(self):
        # create a MonitorModel to communicate with the QML view
        self.monitor_model = MonitorModel()
        self.monitors = self.monitor_model.monitors

        # create a SettingsModel to communicate with the settings drawer
        # in the QML view
        self.settings_model = SettingsModel(self)
        # connect the statAdded and statRemoved signals
        self.settings_model.statAdded.connect(self.add_stat)
        self.settings_model.statRemoved.connect(self.remove_stat)

        if self.qapp is None:
            self.qapp = QtWidgets.QApplication(sys.argv)

            # add custom fonts
            font_db = QtGui.QFontDatabase()
            font_paths = [
                self.get_asset_path('Raleway-Regular.ttf'),
                self.get_asset_path('RobotoMono-Regular.ttf')
            ]
            for font_path in font_paths:
                font_id = font_db.addApplicationFont(font_path)
                if font_id == -1:
                    logging.warn(f'Could not load font ({font_path})')

            font = QtGui.QFont('Raleway')
            self.qapp.setFont(font)

            # set favicon
            icon_info = [('icons/favicon-16x16.png', (16, 16)),
                         ('icons/favicon-32x32.png', (32, 32)),
                         ('icons/android-chrome-192x192.png', (192, 192)),
                         ('icons/android-chrome-256x256.png', (256, 256))]

            app_icon = QtGui.QIcon()
            for path, size in icon_info:
                app_icon.addFile(self.get_asset_path(path),
                                 QtCore.QSize(*size))
            self.qapp.setWindowIcon(app_icon)

        for stat in self.initial_stats:
            self.add_stat(stat, add_to_config=False)

        view = QtQuick.QQuickView()
        view.setResizeMode(QtQuick.QQuickView.SizeRootObjectToView)

        root_context = view.rootContext()
        # make monitor model and settings model available in QML
        root_context.setContextProperty('monitorModel', self.monitor_model)
        root_context.setContextProperty('settingsModel', self.settings_model)

        # qml/view.qml is the root QML file
        qml_file = os.path.join(os.path.dirname(__file__), 'qml', 'view.qml')
        view.setSource(QtCore.QUrl.fromLocalFile(os.path.abspath(qml_file)))

        if view.status() == QtQuick.QQuickView.Error:
            sys.exit(-1)

        def signal_handler(signal, frame):
            # the app can not gracefully quit
            # when there is a keyboard interrupt
            # because the QAbstractListModel catches all errors
            # in a part of its code
            print()
            os._exit(0)

        signal.signal(signal.SIGINT, signal_handler)
        view.show()
        self.qapp.exec_()
        self.quit()
示例#15
0
    def setupUi(self, SplashScreen):
        SplashScreen.setObjectName("SplashScreen")
        SplashScreen.resize(804, 403)
        self.centralwidget = QtWidgets.QWidget(SplashScreen)
        self.centralwidget.setMinimumSize(QtCore.QSize(800, 400))
        self.centralwidget.setMaximumSize(QtCore.QSize(800, 400))
        self.centralwidget.setObjectName("centralwidget")
        self.verticalLayout = QtWidgets.QVBoxLayout(self.centralwidget)
        self.verticalLayout.setContentsMargins(3, 3, 3, 3)
        self.verticalLayout.setSpacing(3)
        self.verticalLayout.setObjectName("verticalLayout")
        self.DropShadowFrame = QtWidgets.QFrame(self.centralwidget)
        self.fontDB = QtGui.QFontDatabase()
        self.fontDB.addApplicationFont(f":/fonts/fonts/CabinSketch-Bold.ttf")
        self.fontDB.addApplicationFont(
            f":/fonts/fonts/CabinSketch-Regular.ttf")
        self.fontDB.addApplicationFont(
            f":/fonts/fonts/CFNightofTerrorPERSONAL-Reg.ttf")
        self.fontDB.addApplicationFont(f":/fonts/fonts/Courgette-Regular.ttf")
        self.fontDB.addApplicationFont(f":/fonts/fonts/DEADLY KILLERS.ttf")
        self.fontDB.addApplicationFont(f":/fonts/fonts/FEASFBI_.ttf")
        self.fontDB.addApplicationFont(f":/fonts/fonts/FEASFBI.ttf")
        self.fontDB.addApplicationFont(f":/fonts/fonts/FEASFBRG.ttf")
        self.fontDB.addApplicationFont(f":/fonts/fonts/Lemon-Regular.ttf")
        self.fontDB.addApplicationFont(
            f":/fonts/fonts/Martyric_PersonalUse.ttf")
        self.fontDB.addApplicationFont(f":/fonts/fonts/monbaiti.ttf")
        self.fontDB.addApplicationFont(f":/fonts/fonts/PirataOne-Regular.ttf")
        self.fontDB.addApplicationFont(":/fonts/fonts/RW-creepsville.ttf")
        font = QtGui.QFont()
        font.setFamily("MS PGothic")
        font.setPointSize(15)
        font.setBold(True)
        font.setWeight(75)
        self.DropShadowFrame.setFont(font)
        self.DropShadowFrame.setStyleSheet(
            "QFrame {\n"
            "    background-color: rgb(53, 4, 10);\n"
            "    color: rgb(252, 72, 90);\n"
            "    border-radius: 12px\n"
            "}")
        self.DropShadowFrame.setFrameShape(QtWidgets.QFrame.NoFrame)
        self.DropShadowFrame.setFrameShadow(QtWidgets.QFrame.Raised)
        self.DropShadowFrame.setObjectName("DropShadowFrame")
        self.AppName = QtWidgets.QLabel(self.DropShadowFrame)
        self.AppName.setGeometry(QtCore.QRect(0, 20, 791, 111))
        font = QtGui.QFont()
        font.setFamily("Creepsville")
        font.setPointSize(45)
        font.setBold(True)
        font.setItalic(True)
        font.setWeight(75)
        font.setKerning(True)
        font.setStyleStrategy(QtGui.QFont.PreferAntialias)
        self.AppName.setFont(font)
        self.AppName.setStyleSheet("color: rgb(159, 8, 23)")
        self.AppName.setAlignment(QtCore.Qt.AlignCenter)
        self.AppName.setObjectName("AppName")
        self.AppDesc = QtWidgets.QLabel(self.DropShadowFrame)
        self.AppDesc.setGeometry(QtCore.QRect(0, 120, 801, 41))
        font = QtGui.QFont()
        font.setFamily("CF Night of Terror PERSONAL")
        font.setPointSize(14)
        font.setBold(False)
        font.setItalic(True)
        font.setWeight(50)
        font.setKerning(True)
        font.setStyleStrategy(QtGui.QFont.PreferAntialias)
        self.AppDesc.setFont(font)
        self.AppDesc.setStyleSheet("color: rgba(135, 42, 70, 220);")
        self.AppDesc.setAlignment(QtCore.Qt.AlignCenter)
        self.AppDesc.setObjectName("AppDesc")
        self.ProgressBar = QtWidgets.QProgressBar(self.DropShadowFrame)
        self.ProgressBar.setGeometry(QtCore.QRect(70, 270, 671, 23))
        self.ProgressBar.setStyleSheet(
            "QProgressBar {\n"
            "    color: rgb(214, 220, 210);\n"
            "    background-color: rgba(85, 6, 16, 200);\n"
            "    border-style: none;\n"
            "    border: 5px qlineargradient(spread:pad, x1:0, y1:0, x2:1, y2:0, stop:0 rgba(158, 7, 23, 255), stop:1 rgba(255, 130, 20, 255));\n"
            "    border-radius: 10px;\n"
            "    text-align: center;\n"
            "}\n"
            "\n"
            "QProgressBar::chunk {\n"
            "    border-radius: 10px;\n"
            "    background-color: qlineargradient(spread:pad, x1:0, y1:0, x2:1, y2:0, stop:0 rgba(253, 128, 20, 255), stop:1 rgba(159, 8, 23, 255));\n"
            "}")
        self.ProgressBar.setProperty("value", 24)
        self.ProgressBar.setObjectName("ProgressBar")
        self.LoadingStatus = QtWidgets.QLabel(self.DropShadowFrame)
        self.LoadingStatus.setGeometry(QtCore.QRect(0, 300, 791, 21))
        font = QtGui.QFont()
        font.setFamily("CF Night of Terror PERSONAL")
        font.setPointSize(12)
        font.setBold(False)
        font.setItalic(False)
        font.setWeight(50)
        font.setKerning(True)
        font.setStyleStrategy(QtGui.QFont.PreferAntialias)
        self.LoadingStatus.setFont(font)
        self.LoadingStatus.setStyleSheet(
            "color: qlineargradient(spread:pad, x1:0.248473, y1:0.483, x2:1, y2:0, stop:0.208955 rgba(131, 62, 40, 231), stop:1 rgba(163, 13, 23, 248));"
        )
        self.LoadingStatus.setAlignment(QtCore.Qt.AlignCenter)
        self.LoadingStatus.setObjectName("LoadingStatus")
        self.CreatedBy = QtWidgets.QLabel(self.DropShadowFrame)
        self.CreatedBy.setGeometry(QtCore.QRect(320, 370, 461, 16))
        font = QtGui.QFont()
        font.setFamily("Comic Sans MS")
        font.setPointSize(8)
        font.setBold(True)
        font.setItalic(False)
        font.setWeight(75)
        font.setKerning(True)
        font.setStyleStrategy(QtGui.QFont.PreferAntialias)
        self.CreatedBy.setFont(font)
        self.CreatedBy.setStyleSheet(
            "color: qlineargradient(spread:pad, x1:0.248473, y1:0.483, x2:1, y2:0, stop:0.208955 rgba(131, 62, 40, 231), stop:1 rgba(163, 13, 23, 248));\n"
            "border-radius: 100px;")
        self.CreatedBy.setAlignment(QtCore.Qt.AlignRight
                                    | QtCore.Qt.AlignTrailing
                                    | QtCore.Qt.AlignVCenter)
        self.CreatedBy.setObjectName("CreatedBy")
        self.Version = QtWidgets.QLabel(self.DropShadowFrame)
        self.Version.setGeometry(QtCore.QRect(10, 0, 55, 16))
        self.Version.setStyleSheet("border: 0px solid;\n"
                                   "border-radius: 10px;")
        self.Version.setObjectName("Version")
        self.verticalLayout.addWidget(self.DropShadowFrame)
        SplashScreen.setCentralWidget(self.centralwidget)

        self.retranslateUi(SplashScreen)
        QtCore.QMetaObject.connectSlotsByName(SplashScreen)
示例#16
0
 def main_font(self, style="Medium", size=12):
     font_db = qtgui.QFontDatabase()
     return font_db.font(self._font_family, style, size)
示例#17
0
 def _font(self, style, size):
     font_db = qtgui.QFontDatabase()
     family = "Raleway"
     font = font_db.font(family, style, size)
     return font
from PySide2 import QtCore, QtWidgets, QtGui

database = QtGui.QFontDatabase()
fontTree = QtWidgets.QTreeWidget()
fontTree.setColumnCount(2)
fontTree.setHeaderLabels(" Font << Smooth Sizes")

for family in database.families():

    familyItem = QtWidgets.QTreeWidgetItem(fontTree)
    familyItem.setText(0, family)
    print(familyItem)

    for style in database.styles(family):
        styleItem = QtWidgets.QTreeWidgetItem(familyItem)
        styleItem.setText(0, style)

        sizes = 0
        for points in database.smoothSizes(family, style):
            sizes += str(int(points)) + " "

        styleItem.setText(1, sizes)
示例#19
0
from PySide2 import QtCore
from PySide2 import QtGui

from gfUtilitiesBelt.core import resources
reload(resources)



fonts = [
    ":/gfFonts/WorkSans-Light",
    ":/gfFonts/WorkSans-Medium",
    ":/gfFonts/WorkSans-Regular",
    ":/gfFonts/WorkSans-SemiBold"
]
for font in fonts:
    if font not in QtGui.QFontDatabase().families():
        QtGui.QFontDatabase.addApplicationFont(font)




class ListIconButton(QtWidgets.QPushButton):
    hoverEntered = QtCore.Signal()
    hoverLeaved = QtCore.Signal()
    clicked = QtCore.Signal()
    rightClicked = QtCore.Signal()
    doubleClicked = QtCore.Signal()


    class DisplayStyle(object):
        kListStyle = 0