What is the correct font designed for using emojis in ttkbootstrap?

[antrrax]

I created a dialog with emojis and used different fonts on Windows and Linux, and in both cases, some emojis are not displayed. See the images.
linux:

windows:

Example
Obs: In Treeview, nothing is displayed in emoji categories, because if it were to display all emojis in some situations with many emojis, the app crashes. It only displays when selecting emoji subcategories.

import sys
import tkinter as tk
from collections import defaultdict
from tkinter import font
from tkinter.scrolledtext import ScrolledText

import ttkbootstrap as ttk
from ttkbootstrap.constants import *
from ttkbootstrap.icons import Emoji
from ttkbootstrap.scrolled import ScrolledFrame, ScrolledText


class EmojiDialog(ttk.Toplevel):
    """Diálogo de emojis"""

    def __init__(self, parent, text_widget, title="Selecione um Emoji", **kwargs):
        super().__init__(parent, **kwargs)
        self.title(title)
        self.geometry("530x500")
        self.resizable(False, False)
        self.text_widget = text_widget

        self.center_window()

        self.transient(parent)
        self.grab_set()

        self.current_category = None
        self.current_subcategory = None
        self.scrolled_frame = None
        self.search_var = tk.StringVar()
        self.emoji_name_var = tk.StringVar(value="Passe o mouse sobre um emoji")

        self.emoji_font = self._get_emoji_font()

        # Organizar emojis por categoria e subcategoria
        self.categories = defaultdict(lambda: defaultdict(list))
        for item in Emoji._ITEMS:
            self.categories[item.category][item.subcategory].append(
                (item.name, item.char)
            )

        self._setup_ui()
        self._setup_keyboard_shortcuts()

        # Seleciona automaticamente a primeira subcategoria ao iniciar
        if self.categories:
            first_cat = list(self.categories.keys())[0]
            first_subcat = list(self.categories[first_cat].keys())[0]
            self._select_subcategory(first_cat, first_subcat, initial_load=True)

            # Seleciona a primeira subcategoria no TreeView
            for child in self.tree.get_children():
                if self.tree.item(child, "values")[0] == first_cat:
                    for subchild in self.tree.get_children(child):
                        if self.tree.item(subchild, "values")[1] == first_subcat:
                            self.tree.selection_set(subchild)
                            self.tree.focus(subchild)
                            break
                    break

    def center_window(self):
        """Centraliza a janela na tela"""
        self.update_idletasks()
        width = self.winfo_width()
        height = self.winfo_height()
        x = (self.winfo_screenwidth() // 2) - (width // 2)
        y = (self.winfo_screenheight() // 2) - (height // 2)
        self.geometry(f"{width}x{height}+{x}+{y}")

    def _setup_keyboard_shortcuts(self):
        """Configura atalhos de teclado"""
        self.bind("<Escape>", lambda e: self.destroy())
        self.bind("<Control-f>", lambda e: self.search_entry.focus_set())

    def _get_emoji_font(self):
        """Retorna a melhor fonte de emoji para o sistema"""
        system = sys.platform.lower()
        if system == "win32":
            return ("Segoe UI Emoji", 12)
        elif system == "darwin":
            return ("Apple Color Emoji", 12)
        else:
            try:
                for font_name in ["Noto Color Emoji", "DejaVu Sans", "FreeSerif"]:
                    if font.Font(family=font_name, exists=True):
                        return (font_name, 12)
            except:
                pass
        return ("", 16)

    def _setup_ui(self):
        """Configura a interface do usuário"""
        # Frame principal
        self.main_frame = ttk.Frame(self)
        self.main_frame.pack(fill=BOTH, expand=YES, padx=5, pady=5)

        # Frame de busca
        self.search_frame = ttk.Frame(self.main_frame)
        self.search_frame.grid(row=0, column=0, columnspan=3, sticky="ew", pady=(0, 5))

        ttk.Label(self.search_frame, text="Buscar:").pack(side=LEFT, padx=(0, 5))
        self.search_entry = ttk.Entry(self.search_frame, textvariable=self.search_var)
        self.search_entry.pack(side=LEFT, fill=X, expand=YES, padx=(0, 5))
        self.search_entry.bind("<KeyRelease>", self._on_search)

        # Botão para limpar busca
        ttk.Button(
            self.search_frame, text="Limpar", command=self._clear_search, width=8
        ).pack(side=RIGHT, padx=(5, 0))

        # TreeView para categorias
        self._create_category_tree()

        # Área para emojis
        self.emoji_area = ttk.Frame(self.main_frame)
        self.emoji_area.grid(row=1, column=2, sticky="nsew", padx=(5, 0))

        # Configuração de grid
        self.main_frame.grid_columnconfigure(0, weight=0, minsize=150)
        self.main_frame.grid_columnconfigure(2, weight=1)
        self.main_frame.grid_rowconfigure(1, weight=1)

        # Frame para botões e label
        self.button_frame = ttk.Frame(self)
        self.button_frame.pack(fill=X, padx=5, pady=(0, 5))

        # Label para mostrar o nome do emoji (à esquerda)
        self.emoji_label = ttk.Label(
            self.button_frame,
            textvariable=self.emoji_name_var,
            anchor="w",
            font=("Helvetica", 10),
            foreground="blue",  # Cor azul para destaque
        )
        self.emoji_label.pack(side=LEFT, fill=X, expand=YES, padx=5)

        # Botão cancelar (à direita)
        ttk.Button(
            self.button_frame, text="Cancelar", command=self.destroy, width=10
        ).pack(side=RIGHT, padx=5)

    def _clear_search(self):
        """Limpa a busca"""
        if not self.search_var.get().strip():
            return

        self.search_var.set("")
        self.search_entry.focus_set()
        self._on_search()

    def _create_category_tree(self):
        """Cria a TreeView com as categorias de emojis"""
        tree_container = ttk.Frame(self.main_frame)
        tree_container.grid(row=1, column=0, sticky="nsew", padx=(0, 5))

        self.tree = ttk.Treeview(
            tree_container, show="tree", selectmode="browse", height=20
        )

        # Scrollbar para a TreeView
        tree_scroll = ttk.Scrollbar(
            tree_container, orient=VERTICAL, command=self.tree.yview
        )
        self.tree.configure(yscrollcommand=tree_scroll.set)

        self.tree.pack(side=LEFT, fill=BOTH, expand=YES)
        tree_scroll.pack(side=RIGHT, fill=Y)

        # Adiciona categorias e subcategorias
        for category in sorted(self.categories.keys()):
            cat_node = self.tree.insert(
                "", END, text=category.capitalize(), values=(category,)
            )
            for subcategory in sorted(self.categories[category].keys()):
                self.tree.insert(
                    cat_node,
                    END,
                    text=subcategory.capitalize(),
                    values=(category, subcategory),
                )

        # Expandir todos os itens
        for child in self.tree.get_children():
            self.tree.item(child, open=True)

        # Bind para seleção de categoria
        self.tree.bind("<<TreeviewSelect>>", self._on_tree_select)

    def _on_tree_select(self, event=None):
        """Handler para seleção no TreeView"""
        selected = self.tree.selection()
        if selected:
            values = self.tree.item(selected[0], "values")
            if len(values) == 1:  # Categoria principal selecionada
                self._clean_emoji_area()
                self.emoji_name_var.set("Selecione uma subcategoria")
                self.search_var.set("")
            elif len(values) == 2:  # Subcategoria selecionada
                self.search_var.set("")
                category, subcategory = values
                self._select_subcategory(category, subcategory)

    def _select_subcategory(self, category, subcategory, initial_load=False):
        """Seleciona e carrega uma subcategoria"""
        self.current_category = category
        self.current_subcategory = subcategory
        self._load_emojis(category, subcategory)

    def _clean_emoji_area(self):
        """Limpa a área de emojis de forma segura"""
        if self.scrolled_frame:
            try:
                self.scrolled_frame.pack_forget()
                self.scrolled_frame.destroy()
            except tk.TclError:
                pass
            self.scrolled_frame = None

    def _load_emojis(self, category, subcategory):
        """Carrega os emojis da subcategoria especificada"""
        self._clean_emoji_area()

        # Cria novo ScrolledFrame
        self.scrolled_frame = ScrolledFrame(
            master=self.emoji_area, autohide=True, bootstyle="round"
        )
        self.scrolled_frame.pack(fill=BOTH, expand=YES)

        # Cria frame interno
        inner_frame = ttk.Frame(self.scrolled_frame)

        # Adiciona emojis da subcategoria
        emoji_items = self.categories.get(category, {}).get(subcategory, [])

        for i, (name, emoji) in enumerate(emoji_items):
            row, col = divmod(i, 6)  # 8 emojis por linha
            btn = ttk.Label(
                inner_frame,
                text=emoji,
                font=self.emoji_font,
                cursor="hand2",
                padding=8,  # Padding ligeiramente maior
                relief="flat",
            )
            btn.grid(row=row, column=col, padx=2, pady=2)

            # Efeito hover
            btn.bind("<Enter>", lambda e, n=name, b=btn: self._on_emoji_hover(n, b))
            btn.bind("<Leave>", lambda e, b=btn: self._on_emoji_leave(b))
            btn.bind("<Button-1>", lambda e, em=emoji: self._on_emoji_select(em))

        inner_frame.pack(fill=BOTH, expand=YES)

    def _on_emoji_hover(self, name, button):
        """Efeito hover no emoji"""
        self.emoji_name_var.set(name)
        button.configure(relief="raised")

    def _on_emoji_leave(self, button):
        """Remove efeito hover"""
        self.emoji_name_var.set("Passe o mouse sobre um emoji")
        button.configure(relief="flat")

    def _on_emoji_select(self, emoji):
        """Insere o emoji selecionado no widget de texto"""
        try:
            # Para widgets Text (tk.Text e ttk.Text)
            if isinstance(self.text_widget, (tk.Text, ttk.Text)):
                if self.text_widget.tag_ranges("sel"):
                    self.text_widget.delete("sel.first", "sel.last")

                self.text_widget.insert(tk.INSERT, emoji)

                # Aplica a fonte de emoji
                pos = self.text_widget.index(tk.INSERT)
                self.text_widget.tag_add("emoji_font", f"{pos}-1c", pos)
                self.text_widget.tag_configure("emoji_font", font=self.emoji_font)

            # Para widgets Entry
            elif isinstance(self.text_widget, (tk.Entry, ttk.Entry)):
                if self.text_widget.selection_present():
                    start = self.text_widget.index(tk.SEL_FIRST)
                    end = self.text_widget.index(tk.SEL_LAST)
                    self.text_widget.delete(start, end)

                self.text_widget.insert(tk.INSERT, emoji)

            # Para ScrolledText do ttkbootstrap
            elif hasattr(self.text_widget, "text"):
                if self.text_widget.text.tag_ranges("sel"):
                    self.text_widget.text.delete("sel.first", "sel.last")

                self.text_widget.text.insert(tk.INSERT, emoji)

                pos = self.text_widget.text.index(tk.INSERT)
                self.text_widget.text.tag_add("emoji_font", f"{pos}-1c", pos)
                self.text_widget.text.tag_configure("emoji_font", font=self.emoji_font)

        except Exception as e:
            print(f"Erro ao inserir emoji: {e}")
        finally:
            self.destroy()

    def _on_search(self, event=None):
        """Handler para busca de emojis"""
        search_term = self.search_var.get().strip().lower()

        if not search_term:
            # Remove seleção do TreeView
            self.tree.selection_remove(self.tree.selection())
            # Limpa a área de emojis
            self._clean_emoji_area()
            self.emoji_name_var.set("Selecione uma subcategoria")
            return

        # Remove seleção do TreeView durante busca
        self.tree.selection_remove(self.tree.selection())

        # Cria novo ScrolledFrame para resultados
        self._clean_emoji_area()
        self.scrolled_frame = ScrolledFrame(
            master=self.emoji_area, autohide=True, bootstyle="round"
        )
        self.scrolled_frame.pack(fill=BOTH, expand=YES)

        inner_frame = ttk.Frame(self.scrolled_frame)

        # Busca em todos os emojis
        results = []
        for category in self.categories.values():
            for subcategory, emoji_items in category.items():
                for name, emoji in emoji_items:
                    if search_term in name.lower():
                        results.append((name, emoji))

        # Limita resultados para melhor performance
        results = results[:100]  # Máximo 100 resultados

        # Mostra resultados
        for i, (name, emoji) in enumerate(results):
            row, col = divmod(i, 8)
            btn = ttk.Label(
                inner_frame,
                text=emoji,
                font=self.emoji_font,
                cursor="hand2",
                padding=8,
                relief="flat",
            )
            btn.grid(row=row, column=col, padx=2, pady=2)

            btn.bind("<Enter>", lambda e, n=name, b=btn: self._on_emoji_hover(n, b))
            btn.bind("<Leave>", lambda e, b=btn: self._on_emoji_leave(b))
            btn.bind("<Button-1>", lambda e, em=emoji: self._on_emoji_select(em))

        inner_frame.pack(fill=BOTH, expand=YES)


# Exemplo de uso
if __name__ == "__main__":
    app = ttk.Window(title="Teste de Diálogo de Emojis", themename="cosmo")

    # Frame principal
    main_frame = ttk.Frame(app)
    main_frame.pack(pady=10, padx=10, fill=BOTH, expand=YES)

    # Label de instrução
    ttk.Label(main_frame, text="Teste com diferentes widgets de texto:").pack(
        anchor="w"
    )

    # Widgets de teste
    widgets = []

    # 1. tk.Entry padrão
    ttk.Label(main_frame, text="tk.Entry:").pack(anchor="w", pady=(10, 0))
    tk_entry = tk.Entry(main_frame)
    tk_entry.pack(fill=X, pady=(0, 5))
    widgets.append(("tk.Entry", tk_entry))

    # 2. ttk.Entry
    ttk.Label(main_frame, text="ttk.Entry:").pack(anchor="w", pady=(5, 0))
    ttk_entry = ttk.Entry(main_frame)
    ttk_entry.pack(fill=X, pady=(0, 5))
    widgets.append(("ttk.Entry", ttk_entry))

    # 3. tk.Text padrão
    ttk.Label(main_frame, text="tk.Text:").pack(anchor="w", pady=(5, 0))
    tk_text = tk.Text(main_frame, height=3)
    tk_text.pack(fill=X, pady=(0, 5))
    widgets.append(("tk.Text", tk_text))

    # 4. ttk.Text
    ttk.Label(main_frame, text="ttk.Text:").pack(anchor="w", pady=(5, 0))
    ttk_text = ttk.Text(main_frame, height=3)
    ttk_text.pack(fill=X, pady=(0, 5))
    widgets.append(("ttk.Text", ttk_text))

    # 5. ScrolledText do ttkbootstrap
    ttk.Label(main_frame, text="ScrolledText (ttkbootstrap):").pack(
        anchor="w", pady=(5, 0)
    )
    scrolled_text = ScrolledText(main_frame, height=3, autohide=True)
    scrolled_text.pack(fill=BOTH, expand=YES, pady=(0, 5))
    widgets.append(("ScrolledText", scrolled_text))

    # Botões para abrir o seletor de emojis
    btn_frame = ttk.Frame(main_frame)
    btn_frame.pack(fill=X, pady=10)

    for text, widget in widgets:
        ttk.Button(
            btn_frame,
            text=f"Emojis para {text}",
            command=lambda w=widget: EmojiDialog(app, w),
        ).pack(side=LEFT, padx=2, fill=X, expand=YES)

    app.mainloop()

[israel-dryer]

Unfortunately, there is not a universal font that works for all platforms. Based on some research, using "Segoe UI Emoji" on Windows, "Apple Color Emoji" on MacOS, and "Noto Color Emoji" on Linux is a safe default.

I am adding built-in Bootstrap Icon support in ttkbootstrap 2.0, so you'll have access to all the icons on https://icons.getbootstrap.com/. This is not coming till late fall this year though, and 2.0 architecture will be a significant change from the current state; so using those font defaults will be the best bet in this case.

[israel-dryer]

The new ttkbootstrap-icons package is a good alternative to this.