Make an OOP implementation

Author: RedFantom

src/pkgIndex.tcl

@@ -1,37 +1,6 @@
-package ifneeded extrafont 1.2  [list apply { dir  {
-	package require Tk
-
-	if {![info exists $dir]} {
-	    set dir [pwd]
-	}
-
-	set os $::tcl_platform(platform)
-	switch -- $os {
-		windows { set os win }
-		unix    {
-			switch -- $::tcl_platform(os) {
-				Darwin { set os darwin }
-				Linux  { set os linux  }
-			}
-		}
-	}
-	set libfile libextrafont[info sharedlibextension]
-	 # Try to guess the tcl-interpreter architecture (32/64 bit) ...
-	set arch $::tcl_platform(pointerSize)
-	switch -- $arch {
-		4 { set arch x32  }
-		8 { set arch x64 }
-		default { error "extrafont: Unsupported architecture: Unexpected pointer-size $arch"}
-	}
-	
-
-	set libfile_abspath [file join [file normalize $dir] $libfile]
-	load $libfile_abspath
-	
-	namespace eval extrafont {}
-	source [file join $dir extrafont.tcl]
-	source [file join $dir futmp.tcl]
-	
-	package provide extrafont 1.2
-
-}} $dir] ;# end of lambda apply
+package ifneeded extrafont 1.2 \
+    "pwd;
+     source extrafont.tcl; \
+     source futmp.tcl; \
+     load [file join [list [pwd]] libextrafont[info sharedlibextension]];
+     package provide extrafont 1.2;"

tests/test_tkextrafont.py

@@ -16,15 +16,16 @@ class TestTkExtraFont(TestCase):
 
     def setUp(self):
         self.window = tk.Tk()
-        tkextrafont.load_extrafont(self.window)
+        tkextrafont.load(self.window)
 
     def test_font_load(self):
-        assert not self.window.is_font_available("Overhaul")
-        loaded = set(self.window.loaded_fonts())
-        self.window.load_font(os.path.join(self.PATH, "overhaul.ttf"))
-        assert len(list(set(self.window.loaded_fonts()) - loaded)) != 0
-        assert self.window.is_font_available("Overhaul")
-        assert "Overhaul" in self.window.loaded_fonts()
+        font = tkextrafont.Font()
+        assert not font.is_font_available("Overhaul")
+        loaded = set(font.loaded_fonts())
+        loaded_font = tkextrafont.Font(file=os.path.join(self.PATH, "overhaul.ttf"))
+        assert len(list(set(font.loaded_fonts()) - loaded)) != 0
+        assert font.is_font_available("Overhaul")
+        assert "Overhaul" in font.loaded_fonts()
 
         label = tk.Label(self.window, text="Overhaul font", font=("Overhaul", 12, "bold"))
         label.pack()

tkextrafont/__init__.py

@@ -8,16 +8,10 @@
 <https://sourceforge.net/projects/irrational-numbers/>
 
 Provides interface to load the extrafont library into a Tk instance by
-loading it into the Tk interpreter. After loading additional functions
-are available on the Tk instance:
-
-load_font: Load a font file into the Tk interpreter
-unload_font: Unload a font family from the Tk interpreter
-loaded_fonts: Return a List of font families loaded with extrafont
-font_info: Return information on the font contained in a font file
-is_font_available: Return whether a font is available for usage
+loading it into the Tk interpreter.
 """
 import tkinter as tk
+import tkinter.font as tkfont
 # Standard Library
 from contextlib import contextmanager
 import os
@@ -74,36 +68,51 @@ def get_file_directory():
     return os.path.dirname(_FILE_DIR)
 
 
-def load_extrafont(window):
-    # type: (tk.Tk) -> None
-    """Load extrafont into a tk interpreter and provide functions"""
-
-    def load_font(file_name):
-        # type: (str) -> None
-        window.tk.call("extrafont::load", file_name)
-
-    def unload_font(font_name):
-        # type: (str) -> None
-        window.tk.call("extrafont::unload", font_name)
-
-    def loaded_fonts():
-        # type: () -> list
-        return window.tk.call("extrafont::query", "families")
-
-    def font_info(file_name):
-        # type: (str) -> List[Dict[str, str]]
-        return list(map(_tk_dict_to_dict, window.tk.call("extrafont::nameinfo", file_name)))
+class Font(tkfont.Font):
+    """
+    tk.Font wrapper that allows loading fonts from a file
 
-    def is_font_available(font_name):
-        # type: (str) -> bool
-        return window.tk.call("extrafont::isAvailable", font_name)
+    Loads tkextrafont if the package has not yet been loaded.
+    """
 
-    window.tk.eval("set dir {}".format(get_file_directory()))
-    with chdir(get_file_directory()):
+    def __init__(self, root=None, font=None, name=None, exists=False, file=None, **options):
+        """
+        :param file: Path to the file to load a font from
+        """
+        if file is None:  # May as well use normal tk.Font
+            tkfont.Font.__init__(self, root, font, name, exists, **options)
+            return
+        self._file = file
+        root = root or tk._default_root
+        if root is None:
+            raise tk.TclError("No Tk instance available to get interpreter from")
+        if not getattr(root, "_tkextrafont_loaded", False):
+            load(root)
+        # Load the font file
+        root.tk.call("extrafont::load", file)
+        tkfont.Font.__init__(self, root, font, name, exists, **options)
+
+    def unload(self):
+        """Unload the current font"""
+        self._tk.call("extrafont::unload", self.name)  # self._tk available after tk.font.Font.__init__
+
+    def loaded_fonts(self) -> List[str]:
+        """Return a list of fonts loaded with extrafont"""
+        return self._tk.call("extrafont::query", "families")
+
+    def font_info(self, fname: str) -> List[Dict[str, str]]:
+        """Return info of a font file"""
+        return list(map(_tk_dict_to_dict, self._tk.call("extrafont::nameinfo", fname)))
+
+    def is_font_available(self, font_name) -> bool:
+        """Return a boolean whether a font is available"""
+        return self._tk.call("extrafont::isAvailable", font_name)
+
+def load(window: tk.Tk):
+    """Load extrafont into a Tk interpreter"""
+    local = os.path.abspath(os.path.dirname(__file__))
+    print(local)
+    with chdir(local):
         window.tk.eval("source pkgIndex.tcl")
-    window.tk.call("package", "require", "extrafont")
-    window.load_font = load_font
-    window.is_font_available = is_font_available
-    window.unload_font = unload_font
-    window.loaded_fonts = loaded_fonts
-    window.font_info = font_info
+        window.tk.eval("package require extrafont")
+        window._tkextrafont_loaded = True