bootstack 0.1.0a1__py3-none-any.whl

bootstack/dialogs/filterdialog.py

@@ -0,0 +1,358 @@
+"""FilterDialog - A dialog for filtering and selecting multiple items from a list.
+
+This module provides a multi-select dialog with optional search and select-all
+functionality. Items can be displayed with checkboxes, and the dialog supports
+both standard and frameless (borderless) display modes.
+"""
+
+from tkinter import Widget
+from typing import Any, Callable, Literal, Optional, Tuple, Union
+from types import SimpleNamespace
+
+from bootstack.widgets.primitives import CheckButton, Frame, Label, Separator
+from bootstack.widgets.types import Master
+from bootstack.widgets.composites.textentry import TextEntry
+from bootstack.runtime.app import Window
+from bootstack.dialogs import Dialog, DialogButton
+from bootstack.widgets.composites.scrollview import ScrollView
+from bootstack.runtime.window_utilities import AnchorPoint
+
+ttk = SimpleNamespace(
+    Checkbutton=CheckButton,
+    Frame=Frame,
+    Label=Label,
+    Separator=Separator,
+    TextEntry=TextEntry,
+    Window=Window,
+)
+
+
+class FilterDialogContent(ttk.Frame):
+    """Internal content frame for FilterDialog.
+
+    This frame contains the search box, select-all checkbox, and scrollable
+    list of checkboxes for filtering items.
+    """
+
+    def __init__(
+            self,
+            master: Master = None,
+            enable_search: bool = False,
+            enable_select_all: bool = False,
+            items: list[str | dict[str, Any]] = None
+    ):
+        """Initialize the FilterDialogContent frame.
+
+        Args:
+            master: Parent widget. If None, uses the default root window.
+            enable_search: If True, includes a search box to filter items by text.
+            enable_select_all: If True, includes a "Select All" checkbox.
+            items: List of items to display. Can be strings or dicts with keys:
+                - text (str): Display text (required for dict items)
+                - value (Any): Value to return when selected (defaults to text)
+                - selected (bool): Initial selection state (defaults to False)
+        """
+        super().__init__(master)
+        self._enable_search = enable_search
+        self._enable_select_all = enable_select_all
+        self._selected_items = []
+        self._items = self._normalize_items(items)
+        self._filter: str | None = None
+        self._check_buttons: dict[str, ttk.Checkbutton] = {}
+        self._select_all_cb: ttk.Checkbutton | None = None
+        self._scroll_container: ttk.Frame | None = None
+        self._build_content()
+
+    def _normalize_items(self, items: list[str | dict[str, Any]] | None) -> list[dict[str, Any]]:
+        """Normalize items to a consistent dict format.
+
+        Args:
+            items: List of strings or dicts representing items.
+
+        Returns:
+            List of dicts with 'text', 'value', and 'selected' keys.
+
+        Raises:
+            ValueError: If a dict item is missing the 'text' key.
+        """
+        if items is None:
+            return []
+
+        out = []
+        for item in items:
+            if isinstance(item, str):
+                out.append(dict(text=item, value=item, selected=False))
+            else:
+                if 'text' not in item:
+                    raise ValueError('Item must have "text" key')
+
+                if 'selected' not in item:
+                    item['selected'] = False
+                item.setdefault('value', item['text'])
+                if item['selected']:
+                    self._selected_items.append(item['value'])
+                out.append(item)
+        return out
+
+    def _build_content(self):
+        """Build and layout all UI components."""
+        # Search box
+        if self._enable_search:
+            search_entry = ttk.TextEntry(self)
+            search_entry.insert_addon(ttk.Label, 'before', icon='search')
+            search_entry.pack(fill='x')
+            search_entry.on_input(self._on_search_input)
+
+        # Select all checkbox
+        if self._enable_select_all:
+            self._select_all_cb = ttk.Checkbutton(self, text='edit.select_all')
+            self._select_all_cb.invoke()
+            self._select_all_cb.invoke()
+            self._select_all_cb['command'] = self._handle_select_all
+            self._select_all_cb.pack(fill='x', padx=8, pady=(12, 8))
+            ttk.Separator(self).pack(fill='x')
+
+        # Scrollable container for checkboxes
+        scroll_view = ScrollView(
+            self,
+            scroll_direction='vertical',
+            scrollbar_visibility='always'
+        )
+        scroll_view.pack(fill='both', expand=False, pady=(8, 0))
+        scroll_view.configure(height=230)
+
+        self._scroll_container = ttk.Frame(scroll_view.canvas)
+        scroll_view.add(self._scroll_container)
+
+        # Stretch container frame to canvas width for full-width checkboxes
+        def _configure_scroll_width(event):
+            scroll_view.canvas.itemconfig(scroll_view._window_id, width=event.width)
+        scroll_view.canvas.bind('<Configure>', _configure_scroll_width)
+
+        # Add item checkboxes
+        for item in self._items:
+            cb = ttk.Checkbutton(self._scroll_container, text=item['text'])
+            cb.invoke()
+            if not item['selected']:
+                cb.invoke()
+            cb['command'] = lambda value=item['value']: self._on_item_clicked(value)
+            cb.pack(fill='x', padx=8, pady=8)
+            self._check_buttons[item['text']] = cb
+
+    def _handle_select_all(self):
+        """Toggle selection state of all checkboxes."""
+        if 'selected' in self._select_all_cb.state():
+            for item in self._check_buttons.values():
+                item.instate(['!selected'], item.invoke)
+        else:
+            for item in self._check_buttons.values():
+                item.instate(['selected'], item.invoke)
+
+    def _on_search_input(self, event):
+        """Filter visible checkboxes based on search text."""
+        self._filter = (event.data['text'] or '').lower()
+
+        for key, cb in self._check_buttons.items():
+            if self._filter in key.lower():
+                cb.pack(fill='x', padx=8, pady=8)
+            else:
+                cb.pack_forget()
+
+    def _on_item_clicked(self, value):
+        """Update selected items list when a checkbox is clicked."""
+        if value in self._selected_items:
+            self._selected_items.remove(value)
+        else:
+            self._selected_items.append(value)
+
+    def get_selected_items(self):
+        """Return the list of selected item values."""
+        return self._selected_items
+
+
+class FilterDialog(ttk.Frame):
+    """A dialog for filtering and selecting multiple items from a list.
+
+    This dialog displays a list of checkboxes with optional search and select-all
+    functionality. When the user clicks OK, the selected values are stored in
+    the result property.
+
+    !!! note "Events"
+
+        `<<SelectionChange>>`: Triggered when OK is clicked and selections are confirmed.
+          Provides `event.data` with key: `selected` (list[Any]).
+
+    Attributes:
+        result (list[Any] | None): List of selected values after dialog is closed,
+            or None if canceled.
+    """
+
+    def __init__(
+            self,
+            master: Master = None,
+            title: str = "Filter",
+            items: list[str | dict[str, Any]] = None,
+            enable_search: bool = False,
+            enable_select_all: bool = False,
+            frameless: bool = False
+    ):
+        """Initialize the FilterDialog.
+
+        Args:
+            master: Parent widget. If None, uses the default root window.
+            title: Dialog window title.
+            items: List of items to display. Can be strings or dicts with keys:
+                - text (str): Display text (required for dict items)
+                - value (Any): Value to return when selected (defaults to text)
+                - selected (bool): Initial selection state (defaults to False)
+            enable_search: If True, includes a search box to filter items by text.
+            enable_select_all: If True, includes a "Select All" checkbox.
+            frameless: If True, removes window decorations and displays with a
+                border frame. Enables dismiss-on-outside-click behavior.
+        """
+        super().__init__(master)
+        self._master = master if master else self.master
+        self._title = title
+        self._items = items or []
+        self._enable_search = enable_search
+        self._enable_select_all = enable_select_all
+        self._frameless = frameless
+        self._content: FilterDialogContent | None = None
+        self._dialog: Dialog | None = None
+        self.result: list[Any] | None = None
+
+    def _build_content(self, parent):
+        """Build the dialog content with FilterDialogContent."""
+        self._content = FilterDialogContent(
+            master=parent,
+            enable_search=self._enable_search,
+            enable_select_all=self._enable_select_all,
+            items=self._items
+        )
+        padding = 0 if self._frameless else 10
+        self._content.pack(fill='both', expand=True, padx=padding, pady=padding)
+
+        # Setup dismiss-on-click for frameless after dialog is built
+        if self._frameless:
+            parent.after(10, self._setup_frameless_dismiss)
+
+    def _on_ok(self, dialog: Dialog):
+        """Save selected items to result when OK button is clicked."""
+        if self._content:
+            self.result = self._content.get_selected_items()
+            # Generate selection changed event on confirmation
+            if self.result is not None:
+                self.event_generate('<<SelectionChange>>', data={"selected": self.result.copy()})
+
+    def on_selection_changed(self, callback: Callable) -> str:
+        """Bind to `<<SelectionChange>>`. Callback receives `event.data = {"selected": list[Any]}`.
+
+        Returns:
+            Binding identifier for use with off_selection_changed().
+        """
+        return self.bind('<<SelectionChange>>', callback, add=True)
+
+    def off_selection_changed(self, bind_id: str = None):
+        """Unbind callback from <<SelectionChange>> event.
+
+        Args:
+            bind_id: Binding identifier from on_selection_changed().
+        """
+        self.unbind('<<SelectionChange>>', bind_id)
+
+    def _on_click(self, event):
+        """Check if click is outside dialog and dismiss if so."""
+        if not self._dialog or not self._dialog.toplevel:
+            return
+
+        try:
+            # Get dialog window bounds
+            x = self._dialog.toplevel.winfo_rootx()
+            y = self._dialog.toplevel.winfo_rooty()
+            w = self._dialog.toplevel.winfo_width()
+            h = self._dialog.toplevel.winfo_height()
+
+            # Check if click is outside dialog
+            if not (x <= event.x_root <= x + w and y <= event.y_root <= y + h):
+                self._dialog.toplevel.destroy()
+        except:
+            pass
+
+    def _setup_frameless_dismiss(self):
+        """Setup dismiss-on-outside-click for frameless dialogs."""
+        if self._frameless and self._dialog and self._dialog.toplevel:
+            # Bind to root window to catch all clicks
+            root = self._dialog.toplevel.winfo_toplevel()
+            while root.master:
+                root = root.master.winfo_toplevel()
+            root.bind('<Button-1>', self._on_click, add='+')
+
+    def show(
+            self,
+            position: Optional[Tuple[int, int]] = None,
+            modal: Optional[bool] = None,
+            *,
+            anchor_to: Optional[Union[Widget, Literal["screen", "cursor", "parent"]]] = None,
+            anchor_point: AnchorPoint = 'center',
+            window_point: AnchorPoint = 'center',
+            offset: Tuple[int, int] = (0, 0),
+            auto_flip: Union[bool, Literal['vertical', 'horizontal']] = False
+    ) -> Optional[list[Any]]:
+        """Show the dialog and return the selected items.
+
+        Args:
+            position: Optional (x, y) coordinates to position the dialog.
+                If provided, takes precedence over anchor-based positioning.
+            modal: Override the mode's default modality.
+                If None, uses True (modal mode).
+            anchor_to: Positioning target. Can be:
+                - Widget: Anchor to a specific widget
+                - "screen": Anchor to screen edges/corners
+                - "cursor": Anchor to mouse cursor location
+                - "parent": Anchor to parent window (same as widget)
+                - None: Centers on parent (default)
+            anchor_point: Point on the anchor target (n, s, e, w, ne, nw, se, sw, center).
+                Default 'center'.
+            window_point: Point on the dialog window (n, s, e, w, ne, nw, se, sw, center).
+                Default 'center'.
+            offset: Additional (x, y) offset in pixels from the anchor position.
+            auto_flip: Smart positioning to keep window on screen.
+                - False: No flipping (default)
+                - True: Flip both vertically and horizontally as needed
+                - 'vertical': Only flip up/down
+                - 'horizontal': Only flip left/right
+
+        Returns:
+            List of selected item values, or None if canceled.
+        """
+        self._dialog: Dialog = Dialog(
+            master=self._master,
+            title=self._title,
+            content_builder=self._build_content,
+            buttons=[
+                DialogButton(text="button.cancel", role="cancel", result=None),
+                DialogButton(
+                    text="button.ok",
+                    role="primary",
+                    result=True,
+                    default=True,
+                    command=self._on_ok
+                )
+            ],
+            minsize=(250, 200),
+            maxsize=(250, 380),
+            resizable=(False, True),
+            mode="modal",
+            frameless=self._frameless
+        )
+
+        self._dialog.show(
+            position=position,
+            modal=modal,
+            anchor_to=anchor_to,
+            anchor_point=anchor_point,
+            window_point=window_point,
+            offset=offset,
+            auto_flip=auto_flip
+        )
+        return self.result

bootstack/dialogs/fontdialog.py

@@ -0,0 +1,339 @@
+"""FontDialog implementation for selecting and previewing fonts."""
+
+import tkinter
+from tkinter import Text, Variable, font
+from types import SimpleNamespace
+from typing import Any, Optional
+
+from typing_extensions import Unpack
+
+from bootstack.constants import *
+from bootstack.core.localization import MessageCatalog
+from bootstack.dialogs.dialog import Dialog, DialogButton, ShowOptions
+from bootstack.runtime.app import Window
+from bootstack.runtime.utility import scale_size
+from bootstack.style.style import get_style
+from bootstack.widgets.primitives import (
+    CheckButton,
+    Frame,
+    Label,
+    LabelFrame,
+    RadioButton,
+    Scrollbar,
+    TreeView,
+)
+
+ttk = SimpleNamespace(
+    Checkbutton=CheckButton,
+    Frame=Frame,
+    Label=Label,
+    Labelframe=LabelFrame,
+    Radiobutton=RadioButton,
+    Scrollbar=Scrollbar,
+    Treeview=TreeView,
+    Text=Text,
+    Variable=Variable,
+    Window=Window,
+    use_style=get_style,
+)
+
+
+class FontDialog:
+    """A dialog for selecting and previewing fonts.
+
+    This dialog provides a comprehensive interface for selecting fonts,
+    including family, size, weight, slant, and effects (underline, overstrike).
+    The selected font is returned as a `tkinter.font.Font` object when OK is
+    pressed, or None if canceled.
+
+    Attributes:
+        result (font.Font | None): The selected font, or None if canceled.
+    """
+
+    def __init__(
+            self,
+            title: str = "font.selector",  # Use semantic key as default
+            master: Optional[tkinter.Misc] = None,
+            default_font: str = "TkDefaultFont"
+    ):
+        """Create a font selection dialog.
+
+        Args:
+            title: The dialog window title. Will be localized automatically.
+                Defaults to semantic key 'font.selector'.
+            master: Parent widget. The dialog will be modal and centered on this widget.
+            default_font: Name of the initial font to display. Can be any valid tkinter
+                font name (e.g., 'TkDefaultFont', 'TkFixedFont', 'TkTextFont',
+                'TkHeadingFont', etc.) or a custom font name.
+        """
+        # Title is now automatically localized by BaseWindow._setup_window
+        self._style = ttk.use_style()
+        self._default = font.nametofont(default_font)
+        self._actual = self._default.actual()
+        self._size = ttk.Variable(value=self._actual["size"])
+        self._family = ttk.Variable(value=self._actual["family"])
+        self._slant = ttk.Variable(value=self._actual["slant"])
+        self._weight = ttk.Variable(value=self._actual["weight"])
+        self._overstrike = ttk.Variable(value=self._actual["overstrike"])
+        self._underline = ttk.Variable(value=self._actual["underline"])
+        self._preview_font = font.Font()
+        self._preview_text: Optional[ttk.Text] = None
+
+        self._slant.trace_add("write", self._update_font_preview)
+        self._weight.trace_add("write", self._update_font_preview)
+        self._overstrike.trace_add("write", self._update_font_preview)
+        self._underline.trace_add("write", self._update_font_preview)
+
+        self._update_font_preview()
+        self._families = {self._family.get()}
+        for f in font.families():
+            if all([f, not f.startswith("@"), "emoji" not in f.lower()]):
+                self._families.add(f)
+
+        # Create the underlying dialog
+        self._dialog = Dialog(
+            master=master,
+            title=title,
+            content_builder=self._create_content,
+            buttons=[
+                DialogButton(
+                    text="button.cancel",
+                    role="cancel",
+                    result=None,
+                ),
+                DialogButton(
+                    text="button.ok",
+                    role="primary",
+                    default=True,
+                    command=lambda dlg: self._on_submit(),
+                    result=self._preview_font,
+                ),
+            ],
+        )
+
+    def _create_content(self, master: tkinter.Widget) -> None:
+        """Create the dialog body with font selection controls."""
+        # Set dialog size
+        width = scale_size(master, 800)
+        height = scale_size(master, 600)
+        if self._dialog.toplevel:
+            self._dialog.toplevel.geometry(f"{width}x{height}")
+
+        family_size_frame = ttk.Frame(master, padding=10)
+        family_size_frame.pack(fill=X, anchor=N)
+        initial_focus = self._font_families_selector(family_size_frame)
+        self._font_size_selector(family_size_frame)
+        self._font_options_selectors(master, padding=10)
+        self._font_preview(master, padding=10)
+
+        # Set initial focus
+        if initial_focus and self._dialog.toplevel:
+            self._dialog.toplevel.after(100, initial_focus.focus_set)
+
+    def _font_families_selector(self, master: tkinter.Misc) -> ttk.Treeview:
+        """Create and populate the font family selection list."""
+        container = ttk.Frame(master)
+        container.pack(fill=BOTH, expand=YES, side=LEFT)
+
+        header = ttk.Label(
+            container,
+            text="font.family",
+            font="TkHeadingFont",
+        )
+        header.pack(fill=X, pady=(0, 2), anchor=N)
+
+        listbox = ttk.Treeview(
+            master=container,
+            height=5,
+            show="",
+            columns=[0],
+        )
+        listbox.column(0, width=scale_size(listbox, 250))
+        listbox.pack(side=LEFT, fill=BOTH, expand=YES)
+
+        listbox_vbar = ttk.Scrollbar(
+            container,
+            command=listbox.yview,
+            orient=VERTICAL,
+            variant="round",
+        )
+        listbox_vbar.pack(side=RIGHT, fill=Y)
+        listbox.configure(yscrollcommand=listbox_vbar.set)
+
+        for f in sorted(self._families):
+            listbox.insert("", iid=f, index='end', tags=[f], values=[f])
+            listbox.tag_configure(f, font=(f, self._size.get()))
+
+        iid = self._family.get()
+        listbox.selection_set(iid)  # select default value
+        listbox.see(iid)  # ensure default is visible
+        listbox.bind("<<TreeviewSelect>>", lambda e: self._on_select_font_family(e))
+        return listbox
+
+    def _font_size_selector(self, master: tkinter.Misc) -> None:
+        """Create and populate the font size selection list."""
+        container = ttk.Frame(master)
+        container.pack(side=LEFT, fill=Y, padx=(10, 0))
+
+        header = ttk.Label(
+            container,
+            text="font.size",
+            font="TkHeadingFont",
+        )
+        header.pack(fill=X, pady=(0, 2), anchor=N)
+
+        sizes_listbox = ttk.Treeview(container, height=7, columns=[0], show="")
+        sizes_listbox.column(0, width=scale_size(sizes_listbox, 48))
+
+        sizes = [*range(8, 13), *range(13, 30, 2), 36, 48, 72]
+        for s in sizes:
+            sizes_listbox.insert("", iid=s, index='end', values=[s])
+
+        iid = self._size.get()
+        sizes_listbox.selection_set(iid)
+        sizes_listbox.see(iid)
+        sizes_listbox.bind("<<TreeviewSelect>>", lambda e: self._on_select_font_size(e))
+
+        sizes_listbox_vbar = ttk.Scrollbar(
+            master=container,
+            orient=VERTICAL,
+            command=sizes_listbox.yview,
+            variant="round",
+        )
+        sizes_listbox.configure(yscrollcommand=sizes_listbox_vbar.set)
+        sizes_listbox.pack(side=LEFT, fill=Y, expand=YES, anchor=N)
+        sizes_listbox_vbar.pack(side=LEFT, fill=Y, expand=YES)
+
+    def _font_options_selectors(self, master: tkinter.Misc, padding: int) -> None:
+        """Create font option controls (weight, slant, effects)."""
+        container = ttk.Frame(master, padding=padding)
+        container.pack(fill=X, padx=2, pady=2, anchor=N)
+
+        weight_lframe = ttk.Labelframe(container, text="font.weight", padding=5)  # Use semantic key
+        weight_lframe.pack(side=LEFT, fill=X, expand=YES)
+        opt_normal = ttk.Radiobutton(
+            master=weight_lframe,
+            text="font.weight.normal",
+            value="normal",
+            variable=self._weight,
+        )
+        opt_normal.invoke()
+        opt_normal.pack(side=LEFT, padx=5, pady=5)
+        opt_bold = ttk.Radiobutton(
+            master=weight_lframe,
+            text="font.weight.bold",
+            value="bold",
+            variable=self._weight,
+        )
+        opt_bold.pack(side=LEFT, padx=5, pady=5)
+
+        slant_lframe = ttk.Labelframe(container, text="font.slant", padding=5)  # Use semantic key
+        slant_lframe.pack(side=LEFT, fill=X, padx=10, expand=YES)
+        opt_roman = ttk.Radiobutton(
+            master=slant_lframe,
+            text="font.slant.roman",
+            value="roman",
+            variable=self._slant,
+        )
+        opt_roman.invoke()
+        opt_roman.pack(side=LEFT, padx=5, pady=5)
+        opt_italic = ttk.Radiobutton(
+            master=slant_lframe,
+            text="font.slant.italic",
+            value="italic",
+            variable=self._slant,
+        )
+        opt_italic.pack(side=LEFT, padx=5, pady=5)
+
+        effects_lframe = ttk.Labelframe(container, text="font.effects", padding=5)  # Use semantic key
+        effects_lframe.pack(side=LEFT, padx=(2, 0), fill=X, expand=YES)
+        opt_underline = ttk.Checkbutton(
+            master=effects_lframe,
+            text="font.effects.underline",
+            variable=self._underline,
+        )
+        opt_underline.pack(side=LEFT, padx=5, pady=5)
+        opt_overstrike = ttk.Checkbutton(
+            master=effects_lframe,
+            text="font.effects.overstrike",
+            variable=self._overstrike,
+        )
+        opt_overstrike.pack(side=LEFT, padx=5, pady=5)
+
+    def _font_preview(self, master: tkinter.Misc, padding: int) -> None:
+        """Create the font preview text widget."""
+        container = ttk.Frame(master, padding=padding, height=scale_size(master, 150))
+        container.pack(fill=BOTH, expand=YES, anchor=N)
+        container.pack_propagate(False)
+
+        header = ttk.Label(
+            container,
+            text="font.preview",
+            font="TkHeadingFont",
+        )
+        header.pack(fill=X, pady=2, anchor=N)
+
+        content = MessageCatalog.translate("font.preview_text")
+        self._preview_text = ttk.Text(
+            master=container,
+            height=3,
+            font=self._preview_font,
+        )
+        self._preview_text.insert(END, content)
+        self._preview_text.pack(fill=BOTH, expand=YES)
+
+    def _on_select_font_family(self, e: tkinter.Event) -> None:
+        """Handle font family selection event."""
+        if not self._dialog.toplevel:
+            return
+        tree: ttk.Treeview = self._dialog.toplevel.nametowidget(e.widget)
+        font_family = tree.selection()[0]
+        self._family.set(value=font_family)
+        self._update_font_preview()
+
+    def _on_select_font_size(self, e: tkinter.Event) -> None:
+        """Handle font size selection event."""
+        if not self._dialog.toplevel:
+            return
+        tree: ttk.Treeview = self._dialog.toplevel.nametowidget(e.widget)
+        fontsize = tree.selection()[0]
+        self._size.set(value=fontsize)
+        self._update_font_preview()
+
+    def _on_submit(self) -> None:
+        """Handle OK button - update result with current font."""
+        self._dialog.result = self._preview_font
+
+    def _update_font_preview(self, *_: Any) -> None:
+        """Update the preview font based on current selections."""
+        family = self._family.get()
+        size = self._size.get()
+        slant = self._slant.get()
+        overstrike = self._overstrike.get()
+        underline = self._underline.get()
+        weight = self._weight.get()
+
+        self._preview_font.config(
+            family=family,
+            size=size,
+            slant=slant,
+            overstrike=overstrike,
+            underline=underline,
+            weight=weight,
+        )
+        if self._preview_text:
+            try:
+                self._preview_text.configure(font=self._preview_font)
+            except Exception:
+                pass
+
+    def show(self, **kwargs: Unpack[ShowOptions]) -> None:
+        """Show the dialog."""
+        kwargs.setdefault('modal', True)
+        kwargs.setdefault('anchor_to', 'screen')
+        self._dialog.show(**kwargs)
+
+    @property
+    def result(self) -> Optional[font.Font]:
+        """The selected font, or None if canceled."""
+        return self._dialog.result