[Python] How to configure the font used to render IME preview text in tkinter text input...

Problem Description


I'm experiencing a problem concerning font configuration in Tkinter. The constructor of all Tkinter widgets have a font keyword argument which allows you to configure the font used for displaying text. However, this option doesn't seem to affect the IME preview text used in text input widgets (such as Entry and Text).

For those whose native language doesn't require IMEs (input method editors), I'll give a short explanation: while the "spelling" of a word/phrase is being entered, these spelling characters aren't immediately entered into the text field being typed in. Instead, the IME of the OS intercepts these spelling characters and translates them into the best-matching candidates as you type. And when you're done, you press Enter and the completed phrase is sent to the application. While you're composing the phrase, it's the application's responsibility to render the "preview" text in a manner which is visually distinct from text that has already been submitted into the text field.

Other applications (both built into Windows and 3rd party) usually uses the same font family and same font size to render the IME preview text, with the only difference being a dotted underline and sometimes a different background color. However, the problem I'm experiencing is that Tkinter always renders the IME preview text using the "default" font regardless of the font that the widget is configured to use.

For example, here's a screenshot of composing Chinese text in Notepad:



And here's a screenshot of doing the same in the Tk application I wrote as an MRE:



As it can be seen, while Notepad uses the same font for both the actual text and the IME preview text, Tkinter uses the default font for the latter, which results in an ugly visual discrepancy (even the placement of the preview text is slightly off).

Minimal Reproducible Example


Here's the code for the MRE used in the screenshot to demonstrate the issue. The DPI configuration is necessary to ensure that one pixel in the window corresponds to one pixel on the physical screen. Otherwise Windows will automatically upscale the window on high DPI displays, causing the window to appear blurry.

#!/usr/bin/env python3
from contextlib import suppress
import tkinter as tk
import tkinter.font
import platform
import ctypes
size = (800, 400)


def configure_dpi() -> bool:
"""Tries to set DPI awareness and returns whether successful."""
with suppress(AttributeError): # For Windows 8.1 and later
# set process DPI awareness to PROCESS_PER_MONITOR_DPI_AWARE (2).
return (ctypes.windll.shcore.SetProcessDpiAwareness(2) == 0)
with suppress(AttributeError): # For Windows Vista and later.
return (ctypes.windll.user32.SetProcessDPIAware() != 0)
return True # Windows version too low to support HiDPI.


def main() -> None:
root = tk.Tk()
root.title("Text Edit")
root.geometry("%dx%d" % size)
root.minsize(*size)
label_font = tk.font.Font(
name="label_font", family="微軟正黑體", size=12, weight=tk.font.NORMAL
)
input_font = tk.font.Font(
name="input_font", family="微軟正黑體", size=16, weight=tk.font.NORMAL
)
top_bar = tk.Frame(root, pady=10)
tk.Label(top_bar, text="Title:", font=label_font).pack(side=tk.LEFT)
entry = tk.Entry(top_bar, font=input_font)
entry.pack(side=tk.LEFT)
top_bar.grid(row=0, column=0, columnspan=2)
text = tk.Text(root, wrap=tk.WORD, font=input_font)
scrollbar = tk.Scrollbar(root, command=text.yview)
text.configure(yscrollcommand=scrollbar.set)
text.grid(row=1, column=0, sticky=tk.NSEW)
scrollbar.grid(row=1, column=1, sticky=tk.NS)
root.rowconfigure(1, weight=1)
root.columnconfigure(0, weight=1)
root.mainloop()


if __name__ == "__main__":
if platform.system() == "Windows":
configure_dpi()
main()


Run this script, and enter some non-IME text into either the single-line or multi-line text box, then compose some text after that using an IME. You should immediately notice that the IME preview text is rendered with a different font and size from the preceding text.

What I've Tried

1. 
   Assuming that the IME preview text's font is probably set to one of the built-in font names (such as TkDefaultFont, TkFixedFont, TkCaptionFont, etc.) in Tkinter's registry (returned by a call to tkinter.font.names()) but not knowing which one, I tried setting the size of every built-in font name to 16⁠pt, thinking that this way I would be guaranteed to hit the font that the preview text is associated with. So I wrote the following function:
   
   def resize_builtin_fonts(root: tk.Tk | tk.Widget, size: int) -> None:
   """Sets the size of all registered font names."""
   for font_name in tk.font.names(root):
   font_obj = tk.font.nametofont(font_name)
   font_obj.configure(size=size)
   
   
   Then I added the function call resize_builtin_fonts(root, 16) after the code to set up the root window and before the call to root.mainloop(). To my surprise, while this (as expected) caused all widgets without an explicit font= keyword argument in the constructor to display text at 16⁠pts, it had no effect on the IME preview text. So apparently the IME preview text operates separately from Tkinter's font registry.
   
   
2. 
   Next, I tried searching through the Tkinter documentation and John Shipman's Tkinter reference, wondering if there was a module-level function or perhaps a method of tkinter.Tk which is dedicated to setting the IME preview text's font. I couldn't find anything that looked like it, but I could have missed something of course.
   
   
3. 
   Next, I tried searching on the internet, but I couldn't find much. The closest thing I found was this page on the Tcler's Wiki talking about how well Tk 8.3 supports Windows IME (emphasize mine):
   
   
   
   Tk 8.3.4+ has support for Windows IME and Linux XIM. In 8.3, this uses the root-window style, but 8.4 has support for "over-the-spot" style IME and XIM. This support was possible with significant assistance from Koichi Yamamoto and Keiichi Takahashi. Koichi has confirmed that the 8.4 support is known to work on Win95 to WinXP using Windows IME, Japanese Win9*, and the ATOK13 IME variants.
   ​
   
   So now I know the IME preview text probably uses the root window style. Assuming that the term means the ttk style for the root window, I looked up the ttk class name of the tkinter.Tk object using print(root.winfo_class()), and found that it is Tk. So I tried to add this to my code:
   
   import tkinter.ttk as ttk
   style = ttk.Style()
   style.configure("Tk", font="input_font")
   
   
   But it had no effect, so apparently there's no such option for the Tk style. Also, the Tk object doesn't even have a style configuration option, and after testing, the Tk object doesn't seem to obey any configurations made to the Tk style, so it seems that the tkinter.Tk object is exempt from ttk styling anyway.
   
   
4. 
   Continuing to pursue the clue found on the Tcler's Wiki about the IME preview text following the root window style (assuming I interpreted it correctly, its phrasing was a little unclear), I guessed next that maybe by "root window style" it meant the configuration of the tkinter.Tk object, so I tried adding:
   
   root.configure(font=input_font)
   
   
   But this raises the exception tkinter.TclError with the message unknown option "-font", so apparently there's no such option.
   

So now I'm at a loss for how to change the font size associated with the "root window style", whatever that means. I've also tried skimming through the tk documentation to see if there's a relevant command I could call from Python using root.tk.eval("command"). But since I don't know any tcl (and have also never used the tk package directly), I found the tk documentation hard to understand. So hopefully someone here knows the solution.

I tried to test my MRE in a Linux virtual machine to see if the same problem exists there, but I simply could not get the ibus IME framework to work at all after installing it in Linux Mint (all keypresses aren't caught by the IME even when an input method is active), so I had to give up.

Continue reading...