it-swarm.com.de

Wie kann man den Schriftstil eines Widgets ändern, ohne die Schriftfamilie/-größe des Widgets zu kennen?

Gibt es eine Möglichkeit, den Schriftstil eines Tkinter - Widgets zu ändern, ohne die Schriftfamilie und die Schriftgröße des Widgets zu kennen?

Anwendungsfall: Wir erstellen unsere Benutzeroberfläche mit Standard Tkinter Widgets ( Label , Entry , Text usw.). Während der Ausführung unserer Anwendung möchten wir möglicherweise den Schriftstil dieser Widgets mithilfe der .config()-Methode dynamisch in Fettdruck und/oder Kursivschrift ändern. Leider scheint es keine Möglichkeit zu geben, eine Schriftartspezifikation anzugeben, ohne die Familie und die Größe der Schriftart anzugeben.

Die folgenden Beispiele zeigen, was wir gerne tun würden, aber keines dieser Beispiele funktioniert:

widget.config(font='bold')

oder

widget.config(font=( None, None, 'bold' ))
41
Malcolm

Es gibt einen viel besseren Weg als .config(), um Ihre Anwendungsschriftart zu ändern, insbesondere wenn Sie die Schriftart für eine ganze Gruppe von Widgets (oder alle Widgets) ändern möchten.

Eines der wirklich tollen Features von Tk ist der Begriff "Named Fonts". Die Schönheit benannter Schriftarten besteht darin, dass beim Aktualisieren der Schriftart alle Widgets, die diese Schriftart verwenden, automatisch aktualisiert werden. Konfigurieren Sie Ihre Widgets also einmal, um diese benutzerdefinierten Schriftarten zu verwenden. Das Ändern der Attribute ist dann trivial.

Hier ein kurzes Beispiel:

try:
    import Tkinter as tk
    import tkFont
#    import ttk  # not used here
except ImportError:  # Python 3
    import tkinter as tk
    import tkinter.font as tkFont
#    import tkinter.ttk as ttk  # not used here

class App:
    def __init__(self):
        root=tk.Tk()
        # create a custom font
        self.customFont = tkFont.Font(family="Helvetica", size=12)

        # create a couple widgets that use that font
        buttonframe = tk.Frame()
        label = tk.Label(root, text="Hello, world", font=self.customFont)
        text = tk.Text(root, width=20, height=2, font=self.customFont)
        buttonframe.pack(side="top", fill="x")
        label.pack()
        text.pack()
        text.insert("end","press +/- buttons to change\nfont size")

        # create buttons to adjust the font
        bigger = tk.Button(root, text="+", command=self.OnBigger)
        smaller = tk.Button(root, text="-", command=self.OnSmaller)
        bigger.pack(in_=buttonframe, side="left")
        smaller.pack(in_=buttonframe, side="left")

        root.mainloop()

    def OnBigger(self):
        '''Make the font 2 points bigger'''
        size = self.customFont['size']
        self.customFont.configure(size=size+2)

    def OnSmaller(self):
        '''Make the font 2 points smaller'''
        size = self.customFont['size']
        self.customFont.configure(size=size-2)

app=App()

Wenn Ihnen dieser Ansatz nicht gefällt oder wenn Sie Ihre benutzerdefinierte Schriftart auf der Standardschriftart basieren möchten oder Sie nur eine oder zwei Schriftarten ändern möchten, um den Status anzuzeigen, können Sie mit font.actual die tatsächliche Größe einer Schriftart ermitteln für ein bestimmtes Widget. Zum Beispiel:

import Tkinter as tk
import tkFont

root = tk.Tk()
label = tk.Label(root, text="Hello, world")
font = tkFont.Font(font=label['font'])
print font.actual()

Wenn ich das oben ausführte, erhalte ich die folgende Ausgabe:

{'family': 'Lucida Grande', 
 'weight': 'normal', 
 'slant': 'roman', 
 'overstrike': False, 
 'underline': False, 
 'size': 13}
49
Bryan Oakley

Noch kürzer für nur ein Label:

from Tkinter import *
import Tkinter as tk
root = tk.Tk()

# font="-weight bold" does your thing
example = Label(root, text="This is a bold example.", font="-weight bold")
example.pack()

root.mainloop()
23
user4226334

verwenden Sie einfach die grundlegenden Attribute eines bestimmten Widgets. Angenommen, Sie möchten die Schriftart eines Labels ändern. Sie können folgende Syntax verwenden:

mlabel = Label(text="Your text", font=("Name of your font",size))

dieser Code funktioniert für Python 3.4

4
kybrdbnd

Wenn Sie eine benannte Schriftart verwenden, können Sie ein paar Anweisungen verwenden, um das zu erhalten, was Sie möchten:

import tkFont
wfont = tkFont.nametofont(widget['font'])
wfont.config(weight='bold')

Bearbeitet um den Kommentar von B. Oakley zu übernehmen. 

4
Brandon

Um die Standardschriftart zu erhalten, ohne sie zu berühren oder ein Widget zu haben, können Sie den generischen Namen der Standardschriftart verwenden.

#!/usr/bin/env python3
import tkinter
import tkinter.font  # Python3!

tkinter.Tk()
default_font = tkinter.font.Font(font='TkDefaultFont')
print(default_font.actual())
0
buhtz

Obwohl es schon einige Zeit her ist, seit dieses Q gefragt wurde, musste ich kürzlich eine Lösung dafür implementieren, die ich für wert hielt, mitzuteilen. Die Funktion widget_font_config (...) läuft auf Python 2 und 3.

Im Wesentlichen wird der "aktuelle Wert" der Schriftart des Widgets übernommen, geändert und dann zurückgesetzt. Benannte Schriftarten werden unterstützt, und der Standardwert inplace_f value von True bedeutet, dass benannte Schriftarten beibehalten und an Ort und Stelle geändert werden. Das Flag kann aber auch auf False gesetzt werden, wodurch eine benannte Schriftart durch eine andere benannte Schriftart ersetzt wird, falls der Benutzer nicht wünscht, dass die Änderungen in der Schriftart des Widgets zu allen anderen durchsickern Widgets, die die benannte Schrift verwenden.

def widget_font_config(widget, inplace_f = True, **kwargs):
    import sys
    if sys.version_info[0] is 2:
        import tkFont
    else:
        import tkinter.font as tkFont
    inplace_f = kwargs.pop('inplace', inplace_f)
    font = None    
    if widget and 'font' in widget.config():
        font_config = widget.config()['font']
        current_font = font_config[4] #grabs current value
        namedfont_f = False
        try:
            font = tkFont.nametofont(current_font)
            namedfont_f = True
        except:
            font = current_font
        if namedfont_f and inplace_f:
            font.config(**kwargs)
        else:
            font_d = tkFont.Font(font=font).actual()
            font_d.update(**kwargs)
            font = tkFont.Font(**font_d)
            widget.config(font=font)
        widget.update_idletasks()
    return font

if __== '__main__':
    import sys
    pyVers = sys.version_info.major
    if pyVers is 2:
        import Tkinter as Tk, tkFont
    else:
        import tkinter as Tk, tkinter.font as tkFont
    def go():
        print(widget_font_config(root.label,  slant='roman', underline=1).actual())
        print(widget_font_config(root.button, overstrike=1).actual())
    root = Tk.Tk()
    font_s = 'Courier 20 italic'
    font_d = dict(family='Courier', size=10, weight='normal', slant='italic')
    font = tkFont.Font(**font_d)
    root.label = Tk.Label(text='Label {}'.format(font_s), font=font_s)
    root.label.pack()
    root.button = Tk.Button(text='Button {}'.format(font), font=font, command=go)
    root.button.pack()
    root.mainloop()
0
Gary02127

Um viele der oben genannten Informationen auf ein einziges Code-Snippet zu reduzieren:

lbl = ttk.Label(blah, blah)   # Make a label
font = tkFont(lbl['font'])    # Get its font
font.config(weight='bold')    # Modify font attributes
lbl['font'] = font            # Tell the label to use the modified font

Dies ermöglicht das Ändern der Schriftartattribute unabhängig von der verwendeten Schriftart (sofern die Schriftart dieses Attribut unterstützt).

Sie können dies auch im laufenden Betrieb tun, um wahrhaft widerliche Schrifteffekte zu erzeugen.

0
user3712955