golden hour

/usr/lib64/python2.7/lib-tk

File/Folder	Size	Actions
Canvas.py	7.29 KB
Canvas.pyc	15.2 KB
Canvas.pyo	15.2 KB
Dialog.py	1.53 KB
Dialog.pyc	1.88 KB
Dialog.pyo	1.88 KB
FileDialog.py	8.62 KB
FileDialog.pyc	9.5 KB
FileDialog.pyo	9.5 KB
FixTk.py	2.87 KB
FixTk.pyc	1.95 KB
FixTk.pyo	1.89 KB
ScrolledText.py	1.79 KB
ScrolledText.pyc	2.6 KB
ScrolledText.pyo	2.6 KB
SimpleDialog.py	3.64 KB
SimpleDialog.pyc	4.24 KB
SimpleDialog.pyo	4.24 KB
Tix.py	75.93 KB
Tix.pyc	94.32 KB
Tix.pyo	94.32 KB
Tkconstants.py	1.46 KB
Tkconstants.pyc	2.19 KB
Tkconstants.pyo	2.19 KB
Tkdnd.py	11.22 KB
Tkdnd.pyc	12.52 KB
Tkdnd.pyo	12.52 KB
Tkinter.py	154.14 KB
Tkinter.pyc	192.89 KB
Tkinter.pyo	192.89 KB
test	-
tkColorChooser.py	1.74 KB
tkColorChooser.pyc	1.39 KB
tkColorChooser.pyo	1.39 KB
tkCommonDialog.py	1.38 KB
tkCommonDialog.pyc	1.48 KB
tkCommonDialog.pyo	1.48 KB
tkFileDialog.py	5.59 KB
tkFileDialog.pyc	5.04 KB
tkFileDialog.pyo	5.04 KB
tkFont.py	5.96 KB
tkFont.pyc	6.93 KB
tkFont.pyo	6.93 KB
tkMessageBox.py	3.6 KB
tkMessageBox.pyc	3.8 KB
tkMessageBox.pyo	3.8 KB
tkSimpleDialog.py	7.54 KB
tkSimpleDialog.pyc	8.9 KB
tkSimpleDialog.pyo	8.9 KB
ttk.py	54.07 KB
ttk.pyc	60.58 KB
ttk.pyo	60.58 KB
turtle.py	135.63 KB
turtle.pyc	136.15 KB
turtle.pyo	136.15 KB

Edit: tkFont.py

# Tkinter font wrapper
#
# written by Fredrik Lundh, February 1998
#
# FIXME: should add 'displayof' option where relevant (actual, families,
#        measure, and metrics)
#

__version__ = "0.9"

import Tkinter

# weight/slant
NORMAL = "normal"
ROMAN = "roman"
BOLD   = "bold"
ITALIC = "italic"

def nametofont(name):
    """Given the name of a tk named font, returns a Font representation.
    """
    return Font(name=name, exists=True)

class Font:

"""Represents a named font.

Constructor options are:

font -- font specifier (name, system font, or (family, size, style)-tuple)
    name -- name to use for this font configuration (defaults to a unique name)
    exists -- does a named font by this name already exist?
       Creates a new named font if False, points to the existing font if True.
       Raises _Tkinter.TclError if the assertion is false.

the following are ignored if font is specified:

family -- font 'family', e.g. Courier, Times, Helvetica
    size -- font size in points
    weight -- font thickness: NORMAL, BOLD
    slant -- font slant: ROMAN, ITALIC
    underline -- font underlining: false (0), true (1)
    overstrike -- font strikeout: false (0), true (1)

"""

def _set(self, kw):
        options = []
        for k, v in kw.items():
            options.append("-"+k)
            options.append(str(v))
        return tuple(options)

def _get(self, args):
        options = []
        for k in args:
            options.append("-"+k)
        return tuple(options)

def _mkdict(self, args):
        options = {}
        for i in range(0, len(args), 2):
            options[args[i][1:]] = args[i+1]
        return options

def __init__(self, root=None, font=None, name=None, exists=False, **options):
        if not root:
            root = Tkinter._default_root
        if font:
            # get actual settings corresponding to the given font
            font = root.tk.splitlist(root.tk.call("font", "actual", font))
        else:
            font = self._set(options)
        if not name:
            name = "font" + str(id(self))
        self.name = name

if exists:
            self.delete_font = False
            # confirm font exists
            if self.name not in root.tk.call("font", "names"):
                raise Tkinter._tkinter.TclError, "named font %s does not already exist" % (self.name,)
            # if font config info supplied, apply it
            if font:
                root.tk.call("font", "configure", self.name, *font)
        else:
            # create new font (raises TclError if the font exists)
            root.tk.call("font", "create", self.name, *font)
            self.delete_font = True
        # backlinks!
        self._root  = root
        self._split = root.tk.splitlist
        self._call  = root.tk.call

def __str__(self):
        return self.name

def __eq__(self, other):
        return self.name == other.name and isinstance(other, Font)

def __getitem__(self, key):
        return self.cget(key)

def __setitem__(self, key, value):
        self.configure(**{key: value})

def __del__(self):
        try:
            if self.delete_font:
                self._call("font", "delete", self.name)
        except (KeyboardInterrupt, SystemExit):
            raise
        except Exception:
            pass

def copy(self):
        "Return a distinct copy of the current font"
        return Font(self._root, **self.actual())

def actual(self, option=None):
        "Return actual font attributes"
        if option:
            return self._call("font", "actual", self.name, "-"+option)
        else:
            return self._mkdict(
                self._split(self._call("font", "actual", self.name))
                )

def cget(self, option):
        "Get font attribute"
        return self._call("font", "config", self.name, "-"+option)

def config(self, **options):
        "Modify font attributes"
        if options:
            self._call("font", "config", self.name,
                  *self._set(options))
        else:
            return self._mkdict(
                self._split(self._call("font", "config", self.name))
                )

configure = config

def measure(self, text):
        "Return text width"
        return int(self._call("font", "measure", self.name, text))

def metrics(self, *options):
        """Return font metrics.

For best performance, create a dummy widget
        using this font before calling this method."""

if options:
            return int(
                self._call("font", "metrics", self.name, self._get(options))
                )
        else:
            res = self._split(self._call("font", "metrics", self.name))
            options = {}
            for i in range(0, len(res), 2):
                options[res[i][1:]] = int(res[i+1])
            return options

def families(root=None):
    "Get font families (as a tuple)"
    if not root:
        root = Tkinter._default_root
    return root.tk.splitlist(root.tk.call("font", "families"))

def names(root=None):
    "Get names of defined fonts (as a tuple)"
    if not root:
        root = Tkinter._default_root
    return root.tk.splitlist(root.tk.call("font", "names"))

# --------------------------------------------------------------------
# test stuff

if __name__ == "__main__":

root = Tkinter.Tk()

# create a font
    f = Font(family="times", size=30, weight=NORMAL)

print f.actual()
    print f.actual("family")
    print f.actual("weight")

print f.config()
    print f.cget("family")
    print f.cget("weight")

print names()

print f.measure("hello"), f.metrics("linespace")

print f.metrics()

f = Font(font=("Courier", 20, "bold"))
    print f.measure("hello"), f.metrics("linespace")

w = Tkinter.Label(root, text="Hello, world", font=f)
    w.pack()

w = Tkinter.Button(root, text="Quit!", command=root.destroy)
    w.pack()

fb = Font(font=w["font"]).copy()
    fb.config(weight=BOLD)

w.config(font=fb)

Tkinter.mainloop()