Lib/lib-tk/tkFont.py

   1 # Tkinter font wrapper
   2 #
   3 # written by Fredrik Lundh, February 1998
   4 #
   5 # FIXME: should add 'displayof' option where relevant (actual, families,
   6 #        measure, and metrics)
   7 #
   8
   9 __version__ = "0.9"
  10
  11 import Tkinter
  12
  13 # weight/slant
  14 NORMAL = "normal"
  15 ROMAN = "roman"
  16 BOLD   = "bold"
  17 ITALIC = "italic"
  18
  19 def nametofont(name):
  20     """Given the name of a tk named font, returns a Font representation.
  21     """
  22     return Font(name=name, exists=True)
  23
  24 class Font:
  25
  26     """Represents a named font.
  27
  28     Constructor options are:
  29
  30     font -- font specifier (name, system font, or (family, size, style)-tuple)
  31     name -- name to use for this font configuration (defaults to a unique name)
  32     exists -- does a named font by this name already exist?
  33        Creates a new named font if False, points to the existing font if True.
  34        Raises _Tkinter.TclError if the assertion is false.
  35
  36        the following are ignored if font is specified:
  37
  38     family -- font 'family', e.g. Courier, Times, Helvetica
  39     size -- font size in points
  40     weight -- font thickness: NORMAL, BOLD
  41     slant -- font slant: ROMAN, ITALIC
  42     underline -- font underlining: false (0), true (1)
  43     overstrike -- font strikeout: false (0), true (1)
  44
  45     """
  46
  47     def _set(self, kw):
  48         options = []
  49         for k, v in kw.items():
  50             options.append("-"+k)
  51             options.append(str(v))
  52         return tuple(options)
  53
  54     def _get(self, args):
  55         options = []
  56         for k in args:
  57             options.append("-"+k)
  58         return tuple(options)
  59
  60     def _mkdict(self, args):
  61         options = {}
  62         for i in range(0, len(args), 2):
  63             options[args[i][1:]] = args[i+1]
  64         return options
  65
  66     def __init__(self, root=None, font=None, name=None, exists=False, **options):
  67         if not root:
  68             root = Tkinter._default_root
  69         if font:
  70             # get actual settings corresponding to the given font
  71             font = root.tk.splitlist(root.tk.call("font", "actual", font))
  72         else:
  73             font = self._set(options)
  74         if not name:
  75             name = "font" + str(id(self))
  76         self.name = name
  77
  78         if exists:
  79             self.delete_font = False
  80             # confirm font exists
  81             if self.name not in root.tk.call("font", "names"):
  82                 raise Tkinter._tkinter.TclError, "named font %s does not already exist" % (self.name,)
  83             # if font config info supplied, apply it
  84             if font:
  85                 root.tk.call("font", "configure", self.name, *font)
  86         else:
  87             # create new font (raises TclError if the font exists)
  88             root.tk.call("font", "create", self.name, *font)
  89             self.delete_font = True
  90         # backlinks!
  91         self._root  = root
  92         self._split = root.tk.splitlist
  93         self._call  = root.tk.call
  94
  95     def __str__(self):
  96         return self.name
  97
  98     def __eq__(self, other):
  99         return self.name == other.name and isinstance(other, Font)
 100
 101     def __getitem__(self, key):
 102         return self.cget(key)
 103
 104     def __setitem__(self, key, value):
 105         self.configure(**{key: value})
 106
 107     def __del__(self):
 108         try:
 109             if self.delete_font:
 110                 self._call("font", "delete", self.name)
 111         except (KeyboardInterrupt, SystemExit):
 112             raise
 113         except Exception:
 114             pass
 115
 116     def copy(self):
 117         "Return a distinct copy of the current font"
 118         return Font(self._root, **self.actual())
 119
 120     def actual(self, option=None):
 121         "Return actual font attributes"
 122         if option:
 123             return self._call("font", "actual", self.name, "-"+option)
 124         else:
 125             return self._mkdict(
 126                 self._split(self._call("font", "actual", self.name))
 127                 )
 128
 129     def cget(self, option):
 130         "Get font attribute"
 131         return self._call("font", "config", self.name, "-"+option)
 132
 133     def config(self, **options):
 134         "Modify font attributes"
 135         if options:
 136             self._call("font", "config", self.name,
 137                   *self._set(options))
 138         else:
 139             return self._mkdict(
 140                 self._split(self._call("font", "config", self.name))
 141                 )
 142
 143     configure = config
 144
 145     def measure(self, text):
 146         "Return text width"
 147         return int(self._call("font", "measure", self.name, text))
 148
 149     def metrics(self, *options):
 150         """Return font metrics.
 151
 152         For best performance, create a dummy widget
 153         using this font before calling this method."""
 154
 155         if options:
 156             return int(
 157                 self._call("font", "metrics", self.name, self._get(options))
 158                 )
 159         else:
 160             res = self._split(self._call("font", "metrics", self.name))
 161             options = {}
 162             for i in range(0, len(res), 2):
 163                 options[res[i][1:]] = int(res[i+1])
 164             return options
 165
 166 def families(root=None):
 167     "Get font families (as a tuple)"
 168     if not root:
 169         root = Tkinter._default_root
 170     return root.tk.splitlist(root.tk.call("font", "families"))
 171
 172 def names(root=None):
 173     "Get names of defined fonts (as a tuple)"
 174     if not root:
 175         root = Tkinter._default_root
 176     return root.tk.splitlist(root.tk.call("font", "names"))
 177
 178 # --------------------------------------------------------------------
 179 # test stuff
 180
 181 if __name__ == "__main__":
 182
 183     root = Tkinter.Tk()
 184
 185     # create a font
 186     f = Font(family="times", size=30, weight=NORMAL)
 187
 188     print f.actual()
 189     print f.actual("family")
 190     print f.actual("weight")
 191
 192     print f.config()
 193     print f.cget("family")
 194     print f.cget("weight")
 195
 196     print names()
 197
 198     print f.measure("hello"), f.metrics("linespace")
 199
 200     print f.metrics()
 201
 202     f = Font(font=("Courier", 20, "bold"))
 203     print f.measure("hello"), f.metrics("linespace")
 204
 205     w = Tkinter.Label(root, text="Hello, world", font=f)
 206     w.pack()
 207
 208     w = Tkinter.Button(root, text="Quit!", command=root.destroy)
 209     w.pack()
 210
 211     fb = Font(font=w["font"]).copy()
 212     fb.config(weight=BOLD)
 213
 214     w.config(font=fb)
 215
 216     Tkinter.mainloop()