ttkbootstrap

https://ttkbootstrap.readthedocs.io/en/latest/
Admin
ttkbootstrap is a supercharged theme extension for tkinter that enables on-demand modern flat style...
Tokens:266,738
Snippets:1,667
Trust Score:9.6
Update:4 months ago
Show doc for...
Tokens:
Raw
### Application Entry Point

Source: https://ttkbootstrap.readthedocs.io/en/latest/gallery/pccleaner

This code initializes the ttkbootstrap application window and starts the main event loop. It requires the ttkbootstrap library to be installed and imported.

```python
if __name__ == '__main__':

    app = ttk.Window("PC Cleaner", "pulse")
    Cleaner(app)
    app.mainloop()
```

--------------------------------

### Install ttkbootstrap from GitHub

Source: https://ttkbootstrap.readthedocs.io/en/latest/gettingstarted/installation

Use this command to install the latest development version of ttkbootstrap directly from its GitHub repository.

```python
python -m pip install git+https://github.com/israel-dryer/ttkbootstrap

```

--------------------------------

### Use Collapsing Frame Widget

Source: https://ttkbootstrap.readthedocs.io/en/latest/gallery/collapsingframe

This example demonstrates how to instantiate and use the `CollapsingFrame` widget. It shows how to add multiple collapsible sections with different titles and bootstyles, each containing checkbuttons. Ensure the `ttkbootstrap` library is installed.

```python
if __name__ == '__main__':

    app = ttk.Window(minsize=(300, 1))

    cf = CollapsingFrame(app)
    cf.pack(fill=BOTH)

    # option group 1
    group1 = ttk.Frame(cf, padding=10)
    for x in range(5):
        ttk.Checkbutton(group1, text=f'Option {x + 1}').pack(fill=X)
    cf.add(child=group1, title='Option Group 1')

    # option group 2
    group2 = ttk.Frame(cf, padding=10)
    for x in range(5):
        ttk.Checkbutton(group2, text=f'Option {x + 1}').pack(fill=X)
    cf.add(group2, title='Option Group 2', bootstyle=DANGER)

    # option group 3
    group3 = ttk.Frame(cf, padding=10)
    for x in range(5):
        ttk.Checkbutton(group3, text=f'Option {x + 1}').pack(fill=X)
    cf.add(group3, title='Option Group 3', bootstyle=SUCCESS)

    app.mainloop()
```

--------------------------------

### Application Initialization and Main Loop

Source: https://ttkbootstrap.readthedocs.io/en/latest/gallery/magicmouse

Initializes the ttkbootstrap application with a window title and theme, then starts the main event loop.

```Python
if __name__ == '__main__':

    app = ttk.Window("Magic Mouse", "yeti")
    MouseUtilities(app)
    app.mainloop()
```

--------------------------------

### Install ttkbootstrap from PyPI

Source: https://ttkbootstrap.readthedocs.io/en/latest/gettingstarted/installation

Use this command to install the latest stable version of ttkbootstrap from the Python Package Index.

```python
python -m pip install ttkbootstrap

```

--------------------------------

### DateEntry Initialization Example

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/widgets/dateentry

Initializes a DateEntry widget with custom date format, first day of the week, start date, and styling. Handles potential ValueErrors for invalid date strings.

```python
from datetime import datetime
from ttkbootstrap.widgets import DateEntry

# Example usage:
# Assuming 'root' is a ttkbootstrap.Window instance
# date_entry = DateEntry(root, dateformat='%Y-%m-%d', firstweekday=0, startdate=datetime(2023, 1, 1), bootstyle='primary', popup_title='Choose a date', raise_exception=True)
# date_entry.pack(padx=10, pady=10)
```

--------------------------------

### Create and Run a Themed Application Window

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/window/window

Instantiate the `Window` class with a custom title and theme, then start the application's main event loop.

```python
app = Window(title="My Application", themename="superhero")
app.mainloop()
```

--------------------------------

### Setup Meter Widget Components

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/widgets/meter

Initializes and configures all visual components of the meter widget, including frames, labels, and event bindings.

```python
def _setup_widget(self) -> None:
    """Initialize and configure all meter components.

    Creates the meter frame, indicator label, text labels, and binds
    event handlers for theme changes and interactivity.
    """
    self.meterframe = Frame(
        master=self, width=self._metersize, height=self._metersize
    )
    self.indicator = Label(self.meterframe)
    self.textframe = Frame(self.meterframe)
    self.textleft = Label(
        master=self.textframe,
        text=self._textleft,
        font=self._subtextfont,
        bootstyle=(self._subtextstyle, "metersubtxt"),
        anchor=S,
        padding=(0, 5),
    )
    self.textcenter = Label(
        master=self.textframe,
        textvariable=self.amountuseddisplayvar,
        bootstyle=(self._bootstyle, "meter"),
        font=self._textfont,
    )
    self.textright = Label(
        master=self.textframe,
        text=self._textright,
        font=self._subtextfont,
        bootstyle=(self._subtextstyle, "metersubtxt"),
        anchor=S,
        padding=(0, 5),
    )
    self.subtext = Label(
        master=self.meterframe,
        text=self._subtext,
        bootstyle=(self._subtextstyle, "metersubtxt"),
        font=self._subtextfont,
        textvariable=self.labelvar,
    )

    self.bind("<<ThemeChanged>>", self._on_theme_change)
    self.bind("<<Configure>>", self._on_theme_change)
    self._set_interactive_bind()
    self._draw_base_image()
    self._draw_meter()

    # set widget geometery
    self.indicator.place(x=0, y=0)
    self.meterframe.pack()
    self._set_show_text()
```

--------------------------------

### Run TTK Creator

Source: https://ttkbootstrap.readthedocs.io/en/latest/themes/themecreator

Execute TTK Creator from the command line after installing ttkbootstrap.

```bash
python -m ttkcreator

```

--------------------------------

### EmojiItem Initialization Examples

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/icons/emoji

Illustrates the initialization of EmojiItem objects with various emoji details, including name, category, subcategory, and the emoji character itself. These examples show how different emojis are represented within the system.

```python
EmojiItem("ROLLING ON THE FLOOR LAUGHING", "smiley-emotion", "face-smiling", "🤣")
```

```python
EmojiItem("UPSIDE-DOWN FACE", "smiley-emotion", "face-smiling", "🙃")
```

```python
EmojiItem("SLIGHTLY SMILING FACE", "smiley-emotion", "face-smiling", "🙂")
```

```python
EmojiItem("SMILING FACE WITH SMILING EYES", "smiley-emotion", "face-smiling", "😊")
```

```python
EmojiItem("WINKING FACE", "smiley-emotion", "face-smiling", "😉")
```

```python
EmojiItem("SMILING FACE WITH HALO", "smiley-emotion", "face-smiling", "😇")
```

```python
EmojiItem("SMILING FACE WITH OPEN MOUTH AND TIGHTLY-CLOSED EYES", "smiley-emotion", "face-smiling", "😆")
```

```python
EmojiItem("SMILING FACE WITH OPEN MOUTH AND COLD SWEAT", "smiley-emotion", "face-smiling", "😅")
```

```python
EmojiItem("SMILING FACE WITH OPEN MOUTH AND SMILING EYES", "smiley-emotion", "face-smiling", "😄")
```

```python
EmojiItem("SMILING FACE WITH OPEN MOUTH", "smiley-emotion", "face-smiling", "😃")
```

```python
EmojiItem("FACE WITH TEARS OF JOY", "smiley-emotion", "face-smiling", "😂")
```

```python
EmojiItem("GRINNING FACE WITH SMILING EYES", "smiley-emotion", "face-smiling", "😁")
```

```python
EmojiItem("GRINNING FACE", "smiley-emotion", "face-smiling", "😀")
```

```python
EmojiItem("GRINNING FACE WITH ONE LARGE AND ONE SMALL EYE", "smiley-emotion", "face-tongue", "🤪")
```

```python
EmojiItem("MONEY-MOUTH FACE", "smiley-emotion", "face-tongue", "🤑")
```

```python
EmojiItem("FACE WITH STUCK-OUT TONGUE AND TIGHTLY-CLOSED EYES", "smiley-emotion", "face-tongue", "😝")
```

```python
EmojiItem("FACE WITH STUCK-OUT TONGUE AND WINKING EYE", "smiley-emotion", "face-tongue", "😜")
```

```python
EmojiItem("FACE WITH STUCK-OUT TONGUE", "smiley-emotion", "face-tongue", "😛")
```

```python
EmojiItem("FACE SAVOURING DELICIOUS FOOD", "smiley-emotion", "face-tongue", "😋")
```

```python
EmojiItem("FREEZING FACE", "smiley-emotion", "face-unwell", "🥶")
```

```python
EmojiItem("OVERHEATED FACE", "smiley-emotion", "face-unwell", "🥵")
```

```python
EmojiItem("FACE WITH UNEVEN EYES AND WAVY MOUTH", "smiley-emotion", "face-unwell", "🥴")
```

```python
EmojiItem("SHOCKED FACE WITH EXPLODING HEAD", "smiley-emotion", "face-unwell", "🤯")
```

```python
EmojiItem("FACE WITH OPEN MOUTH VOMITING", "smiley-emotion", "face-unwell", "🤮")
```

```python
EmojiItem("SNEEZING FACE", "smiley-emotion", "face-unwell", "🤧")
```

```python
EmojiItem("NAUSEATED FACE", "smiley-emotion", "face-unwell", "🤢")
```

```python
EmojiItem("FACE WITH HEAD-BANDAGE", "smiley-emotion", "face-unwell", "🤕")
```

```python
EmojiItem("FACE WITH THERMOMETER", "smiley-emotion", "face-unwell", "🤒")
```

```python
EmojiItem("FACE WITH MEDICAL MASK", "smiley-emotion", "face-unwell", "😷")
```

```python
EmojiItem("DIZZY FACE", "smiley-emotion", "face-unwell", "😵")
```

```python
EmojiItem("SPEAK-NO-EVIL MONKEY", "smiley-emotion", "monkey-face", "🙊")
```

```python
EmojiItem("HEAR-NO-EVIL MONKEY", "smiley-emotion", "monkey-face", "🙉")
```

```python
EmojiItem("SEE-NO-EVIL MONKEY", "smiley-emotion", "monkey-face", "🙈")
```

--------------------------------

### Creating and Configuring Disabled Buttons

Source: https://ttkbootstrap.readthedocs.io/en/latest/styleguide/button

Provides examples for creating a button in a disabled state initially and for disabling an existing button.

```python
# create the button in a disabled state
Button(state="disabled")
```

```python
# disable a button after creation
b = Button()
b.configure(state="disabled")
```

--------------------------------

### Initialize BackMeUp Application

Source: https://ttkbootstrap.readthedocs.io/en/latest/gallery/filebackup

Initializes the main application frame, loads image assets, and sets up the button bar with various actions like 'New backup set', 'Backup', 'Refresh', 'Stop', and 'Settings'. Each button is configured with an image and a command that displays a message box.

```python
from datetime import datetime
from random import choices
import ttkbootstrap as ttk
from ttkbootstrap.style import Bootstyle
from tkinter.filedialog import askdirectory
from ttkbootstrap.dialogs import Messagebox
from ttkbootstrap.constants import *
from tkinter.scrolledtext import ScrolledText
from pathlib import Path


PATH = Path(__file__).parent / 'assets'


class BackMeUp(ttk.Frame):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.pack(fill=BOTH, expand=YES)

        image_files = {
            'properties-dark': 'icons8_settings_24px.png',
            'properties-light': 'icons8_settings_24px_2.png',
            'add-to-backup-dark': 'icons8_add_folder_24px.png',
            'add-to-backup-light': 'icons8_add_book_24px.png',
            'stop-backup-dark': 'icons8_cancel_24px.png',
            'stop-backup-light': 'icons8_cancel_24px_1.png',
            'play': 'icons8_play_24px_1.png',
            'refresh': 'icons8_refresh_24px_1.png',
            'stop-dark': 'icons8_stop_24px.png',
            'stop-light': 'icons8_stop_24px_1.png',
            'opened-folder': 'icons8_opened_folder_24px.png',
            'logo': 'backup.png'
        }

        self.photoimages = []
        imgpath = Path(__file__).parent / 'assets'
        for key, val in image_files.items():
            _path = imgpath / val
            self.photoimages.append(ttk.PhotoImage(name=key, file=_path))

        # buttonbar
        buttonbar = ttk.Frame(self, style='primary.TFrame')
        buttonbar.pack(fill=X, pady=1, side=TOP)

        ## new backup
        _func = lambda: Messagebox.ok(message='Adding new backup')
        btn = ttk.Button(
            master=buttonbar, text='New backup set',
            image='add-to-backup-light', 
            compound=LEFT, 
            command=_func
        )
        btn.pack(side=LEFT, ipadx=5, ipady=5, padx=(1, 0), pady=1)

        ## backup
        _func = lambda: Messagebox.ok(message='Backing up...')
        btn = ttk.Button(
            master=buttonbar, 
            text='Backup', 
            image='play', 
            compound=LEFT, 
            command=_func
        )
        btn.pack(side=LEFT, ipadx=5, ipady=5, padx=0, pady=1)

        ## refresh
        _func = lambda: Messagebox.ok(message='Refreshing...')
        btn = ttk.Button(
            master=buttonbar, 
            text='Refresh', 
            image='refresh',
            compound=LEFT, 
            command=_func
        )
        btn.pack(side=LEFT, ipadx=5, ipady=5, padx=0, pady=1)

        ## stop
        _func = lambda: Messagebox.ok(message='Stopping backup.')
        btn = ttk.Button(
            master=buttonbar, 
            text='Stop', 
            image='stop-light',
            compound=LEFT, 
            command=_func
        )
        btn.pack(side=LEFT, ipadx=5, ipady=5, padx=0, pady=1)

        ## settings
        _func = lambda: Messagebox.ok(message='Changing settings')
        btn = ttk.Button(
            master=buttonbar, 
            text='Settings', 
            image='properties-light',
            compound=LEFT, 
            command=_func
        )
        btn.pack(side=LEFT, ipadx=5, ipady=5, padx=0, pady=1)

        # left panel
        left_panel = ttk.Frame(self, style='bg.TFrame')
        left_panel.pack(side=LEFT, fill=Y)

        ## backup summary (collapsible)
        bus_cf = CollapsingFrame(left_panel)
        bus_cf.pack(fill=X, pady=1)

        ## container
        bus_frm = ttk.Frame(bus_cf, padding=5)
        bus_frm.columnconfigure(1, weight=1)
        bus_cf.add(
            child=bus_frm, 
            title='Backup Summary', 
            bootstyle=SECONDARY)

        ## destination
        lbl = ttk.Label(bus_frm, text='Destination:')
        lbl.grid(row=0, column=0, sticky=W, pady=2)
        lbl = ttk.Label(bus_frm, textvariable='destination')
        lbl.grid(row=0, column=1, sticky=EW, padx=5, pady=2)
        self.setvar('destination', 'd:/test/')

```

--------------------------------

### Get DateEntry Widget Configuration

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/widgets/dateentry

Retrieve specific configuration values from a DateEntry widget, such as its current state, date format, first weekday, start date, or bootstyle.

```python
state = self.dateentry.cget("state")
dateformat = self.dateentry.cget("dateformat")
bootstyle = self.dateentry.cget("bootstyle")
```

--------------------------------

### Get Date - Querybox

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/dialogs/querybox

Opens a date picker dialog and returns the selected date. Allows customization of parent, title, first weekday, start date, and bootstyle.

```python
Querybox.get_date(title="Select a date", firstweekday=0, startdate=date(2023, 1, 1))
```

--------------------------------

### Initialize Tableview with Constructor

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/tableview/tableview

Demonstrates how to create a Tableview instance with initial column and row data. Use this when you have data readily available at widget creation. Supports features like pagination, search, and custom styling.

```python
import ttkbootstrap as ttk
from ttkbootstrap.tableview import Tableview
from ttkbootstrap.constants import *

app = ttk.Window()
colors = app.style.colors

coldata = [
    {"text": "LicenseNumber", "stretch": False},
    "CompanyName",
    {"text": "UserCount", "stretch": False},
]

rowdata = [
    ('A123', 'IzzyCo', 12),
    ('A136', 'Kimdee Inc.', 45),
    ('A158', 'Farmadding Co.', 36)
]

dt = Tableview(
    master=app,
    coldata=coldata,
    rowdata=rowdata,
    paginated=True,
    searchable=True,
    bootstyle=PRIMARY,
    stripecolor=(colors.light, None),
)
dt.pack(fill=BOTH, expand=YES, padx=10, pady=10)

app.mainloop()
```

--------------------------------

### Meter Widget Initialization and Configuration

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/widgets/meter

Demonstrates how to initialize a Meter widget and configure its properties. It also shows how to update the amount used, link it to an Entry widget, and modify the subtext.

```APIDOC
## Meter Widget Initialization and Usage

### Description
This section details the initialization of the Meter widget and provides examples of its common configurations and methods.

### Initialization Parameters

- **master** (Widget): The parent widget.
- **bootstyle** (str): Sets the indicator and center text color. One of primary, secondary, success, info, warning, danger, light, dark.
- **arcrange** (int): The range of the arc if degrees from start to end.
- **arcoffset** (int): The amount to offset the arc's starting position in degrees. 0 is at 3 o'clock.
- **amountmin** (Union[int, float]): The minimum value of the meter. Defaults to 0. Can be set to a negative value to support negative ranges.
- **amounttotal** (Union[int, float]): The maximum value of the meter.
- **amountused** (Union[int, float]): The current value of the meter; displayed in a center label if the `showtext` property is set to True.
- **amountformat** (str): The format used to display the `amountused` value. Default is "{:.0f}"
- **wedgesize** (int): Sets the length of the indicator wedge around the arc. If greater than 0, this wedge is set as an indicator centered on the current meter value.
- **metersize** (int): The meter is square. This represents the size of one side if the square as measured in screen units.
- **metertype** (str): Displays the meter as a full circle or semi-circle. ('full', 'semi')
- **meterthickness** (int): The thickness of the indicator.
- **showtext** (bool): Indicates whether to show the left, center, and right text labels on the meter.
- **interactive** (bool): Indicates that the user may adjust the meter value with mouse interaction.
- **stripethickness** (int): The indicator can be displayed as a solid band or as striped wedges around the arc. If the value is greater than 0, the indicator changes from a solid to striped, where the value is the thickness of the stripes (or wedges).
- **textleft** (str): A short string inserted to the left of the center text.
- **textright** (str): A short string inserted to the right of the center text.
- **textfont** (Union[str, Font]): The font used to render the center text.
- **subtext** (str): Supplemental text that appears below the center text.
- **subtextstyle** (str): The bootstyle color of the subtext. One of primary, secondary, success, info, warning, danger, light, dark. The default color is Theme specific and is a lighter shade based on whether it is a 'light' or 'dark' theme.
- **subtextfont** (Union[str, Font]): The font used to render the subtext.
- **stepsize** (Union[int, float]): Sets the amount by which to change the meter indicator when incremented by mouse interaction.
- **kwargs**: Other keyword arguments that are passed directly to the `Frame` widget that contains the meter components.

### Methods

- **configure(**
    amountused: Optional[Union[int, float]] = None,
    subtext: Optional[str] = None,
    **kwargs: Any,
**)**: Updates the meter's properties.

- **step(**
    amount: Union[int, float] = 1,
**)**: Increments or decrements the meter's value by the specified amount.

### Example Usage
```python
# update the amount used directly
meter.configure(amountused = 50)

# update the amount used with another widget
entry = ttk.Entry(textvariable=meter.amountusedvar)
entry.pack(fill=X)

# increment the amount by 10 steps
meter.step(10)

# decrement the amount by 15 steps
meter.step(-15)

# update the subtext
meter.configure(subtext="loading...")
```
```

--------------------------------

### start(step_size=None, interval=None)

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/widgets/floodgauge

Starts the progress animation for the Floodgauge widget. It can be used for both indeterminate and determinate modes.

```APIDOC
## start(step_size=None, interval=None)

### Description
Start the progress animation. For indeterminate mode, starts the bouncing animation. For determinate mode, starts auto-incrementing the value.

### Parameters
#### Path Parameters
- **step_size** (`int`) - Optional - Amount to increment per animation step. Defaults to 8 for indeterminate mode, 1 for determinate mode.
- **interval** (`int`) - Optional - Time in milliseconds between animation steps. Defaults to 20ms for indeterminate mode, 50ms for determinate mode.

### Method
```python
def start(self, step_size: Optional[int] = None, interval: Optional[int] = None) -> None:
    """Start the progress animation.

    For indeterminate mode, starts the bouncing animation. For determinate
    mode, starts auto-incrementing the value.

    Parameters:
        step_size (int, optional): Amount to increment per animation step.
                                  Defaults to 8 for indeterminate mode,
                                  1 for determinate mode.

        interval (int, optional): Time in milliseconds between animation steps.
                                 Defaults to 20ms for indeterminate mode,
                                 50ms for determinate mode.
    """
    if self.mode == "indeterminate":
        self._step_size = step_size if step_size is not None else 8
        interval = interval if interval is not None else 20
    else:
        self._step_size = step_size if step_size is not None else 1
        interval = interval if interval is not None else 50

    self._running = True
    self._pulse_direction = 1
    self._run_animation(interval)
```
```

--------------------------------

### Toplevel Window Initialization with Various Options

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/window/toplevel

This snippet demonstrates initializing a Toplevel window with a wide range of configuration options. It handles icon setting, title, size, position, minimum and maximum dimensions, resizability, transient state, window manager attributes like type and topmost, toolwindow style on Windows, and alpha transparency.

```python
def __init__(self, title="", size=None, position=None, minsize=None, maxsize=None, resizable=None, transient=None, overrideredirect=False, windowtype=None, topmost=False, toolwindow=False, alpha=None, iconphoto='', **kwargs):
    """
    Initialize a Toplevel window with various configuration options.

    :param title (str): The title of the window.
    :param size (tuple[int, int]): The initial width and height of the window.
    :param position (tuple[int, int]): The initial x and y position of the window.
    :param minsize (tuple[int, int]): Specifies the minimum permissible dimensions for the
        window. Internally, this argument is passed to the
        `Toplevel.minsize` method.

    :param maxsize (tuple[int, int]):
        Specifies the maximum permissible dimensions for the
        window. Internally, this argument is passed to the
        `Toplevel.maxsize` method.

    :param resizable (tuple[bool, bool]):
        Specifies whether the user may interactively resize the
        toplevel window. Must pass in two arguments that specify
        this flag for _horizontal_ and _vertical_ dimensions.
        This can be adjusted after the window is created by using
        the `Toplevel.resizable` method.

    :param transient (Union[Tk, Widget]):
        Instructs the window manager that this widget is
        transient with regard to the widget master. Internally
        this is passed to the `Toplevel.transient` method.

    :param overrideredirect (bool):
        Instructs the window manager to ignore this widget if
        True. Internally, this argument is processed as
        `Toplevel.overrideredirect(1)`.

    :param windowtype (str):
        On X11, requests that the window should be interpreted by
        the window manager as being of the specified type. Internally,
        this is passed to the `Toplevel.attributes('-type', windowtype)`.

        See the [-type option](https://tcl.tk/man/tcl8.6/TkCmd/wm.htm#M64)
        for a list of available options.

    :param topmost (bool):
        Specifies whether this is a topmost window (displays above all
        other windows). Internally, this processed by the window as
        `Toplevel.attributes('-topmost', 1)`.

    :param toolwindow (bool):
        On Windows, specifies a toolwindow style. Internally, this is
        processed as `Toplevel.attributes('-toolwindow', 1)`.

    :param alpha (float):
        On Windows, specifies the alpha transparency level of the
        toplevel. Where not supported, alpha remains at 1.0. Internally,
        this is processed as `Toplevel.attributes('-alpha', alpha)`.

    **kwargs (Dict):
        Other optional keyword arguments.
    """
    if 'iconify' in kwargs:
        iconify = kwargs.pop('iconify')
    else:
        iconify = None

    super().__init__(**kwargs)
    self.winsys: str = self.tk.call('tk', 'windowingsystem')

    if iconphoto != '':
        try:
            # the user provided an image path
            self._icon = tkinter.PhotoImage(file=iconphoto, master=self)
            self.iconphoto(True, self._icon)
        except tkinter.TclError:
            # The fallback icon if the user icon fails.
            print('iconphoto path is bad; using default image.')
            pass

    self.title(title)

    if size is not None:
        width, height = size
        self.geometry(f'{width}x{height}')

    if position is not None:
        xpos, ypos = position
        self.geometry(f'+{xpos}+{ypos}')

    if minsize is not None:
        width, height = minsize
        self.minsize(width, height)

    if maxsize is not None:
        width, height = maxsize
        self.maxsize(width, height)

    if resizable is not None:
        width, height = resizable
        self.resizable(width, height)

    if iconify:
        self.iconify()

    if transient is not None:
        self.transient(transient)

    if overrideredirect:
        self.overrideredirect(1)

    if windowtype is not None:
        if self.winsys == 'x11':
            self.attributes("-type", windowtype)

    if topmost:
        self.attributes("-topmost", 1)

    if toolwindow:
        if self.winsys == 'win32':
            self.attributes("-toolwindow", 1)

    if alpha is not None:
        if self.winsys == 'x11':
            self.alpha = alpha
            self.alpha_bind = self.bind("<Visibility>", on_visibility, '+')
        else:
            self.attributes("-alpha", alpha)

```

--------------------------------

### QueryDialog Initialization Example

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/dialogs/querydialog

This snippet shows the basic structure of a QueryDialog, including how to set up buttons and pack them within the dialog frame. It demonstrates the use of ttk.Button and ttk.Separator.

```python
cancel = ttk.Button(
            master=frame,
            bootstyle="secondary",
            text=MessageCatalog.translate("Cancel"),
            command=self.on_cancel,
        )
        cancel.pack(padx=5, side=RIGHT)
        cancel.lower()

        ttk.Separator(self._toplevel).pack(fill=X)
        frame.pack(side=BOTTOM, fill=X, anchor=S)
```

--------------------------------

### Window Initialization

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/window/window

Initialize a new Window object with various configuration options.

```APIDOC
## Window Initialization

### Description
Initializes a new `Window` object, which is a top-level window.

### Parameters

#### Keyword Arguments
- **transient** (Union[Tk, Widget]) - Transient window hint.
- **overrideredirect** (bool) - If True, instructs the window manager to ignore the widget.
- **alpha** (float) - Alpha transparency level (Windows only).
- **hdpi** (bool) - Enable high DPI awareness.
- **scaling** (float) - Scaling factor for high DPI awareness.
- **iconphoto** (str or None) - Path to an icon file or None for default.
- **title** (str) - The window title.
- **size** (tuple[int, int]) - Initial window size (width, height).
- **position** (tuple[int, int]) - Initial window position (x, y).
- **minsize** (tuple[int, int]) - Minimum window size (width, height).
- **maxsize** (tuple[int, int]) - Maximum window size (width, height).
- **resizable** (tuple[bool, bool]) - Whether the window is resizable in width and height.
- **themename** (str) - The name of the ttkbootstrap theme to apply.
- **kwargs**: Additional keyword arguments passed to the tkinter.Tk() constructor.
```

--------------------------------

### Start Floodgauge Animation

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/widgets/floodgauge

Starts the progress animation. For indeterminate mode, it begins the bouncing animation. For determinate mode, it initiates auto-incrementing the value.

```python
def start(self, step_size: Optional[int] = None, interval: Optional[int] = None) -> None:
        """Start the progress animation.

        For indeterminate mode, starts the bouncing animation. For determinate
        mode, starts auto-incrementing the value.


```

--------------------------------

### Initialize ttkbootstrap with a Theme

Source: https://ttkbootstrap.readthedocs.io/en/latest/gettingstarted/tutorial

Choose a theme for your application using the Style object or the Window class. The default theme is 'litera'.

```python
import ttkbootstrap as ttk

# traditional approach
root = ttk.Tk()
style = ttk.Style("darkly")

# new approach
root = ttk.Window(themename="darkly")

```

--------------------------------

### Get Table Rows with Filters

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/tableview/tableview

Retrieve a list of TableRow objects. Use 'visible', 'filtered', or 'selected' flags to get a subset of rows. Only one flag can be active at a time.

```python
def get_rows(self, visible=False, filtered=False, selected=False) -> list[TableRow]:
    """Return a list of TableRow objects.

    Return a subset of rows based on optional flags. Only ONE flag can be used
    at a time. If more than one flag is set to `True`, then the first flag will
    be used to return the data.

    Parameters:

        visible (bool):
            If true, only records in the current view will be returned.

        filtered (bool):
            If True, only rows in the filtered dataset will be returned.

        selected (bool):
            If True, only rows that are currently selected will be returned.

    Returns:

        list[TableRow]:
            A list of TableRow objects.
    """
    if visible:
        return self._viewdata
    elif filtered:
        return self._tablerows_filtered
    elif selected:
        return [row for row in self._viewdata if row.iid in self.view.selection()]
    else:
        return self._tablerows
```

--------------------------------

### __init__

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/style/colors

Initializes the Style class with a comprehensive set of theme colors for widgets.

```APIDOC
## __init__

### Description
Initializes the Style class with a comprehensive set of theme colors for widgets.

### Parameters
#### Path Parameters
- **primary** (str) - Required - The primary theme color; used by default for all widgets.
- **secondary** (str) - Required - An accent color; commonly of a `grey` hue.
- **success** (str) - Required - An accent color; commonly of a `green` hue.
- **info** (str) - Required - An accent color; commonly of a `blue` hue.
- **warning** (str) - Required - An accent color; commonly of an `orange` hue.
- **danger** (str) - Required - An accent color; commonly of a `red` hue.
- **light** (str) - Required - An accent color.
- **dark** (str) - Required - An accent color.
- **bg** (str) - Required - Background color.
- **fg** (str) - Required - Default text color.
- **selectfg** (str) - Required - The color of selected text.
- **selectbg** (str) - Required - The background color of selected text.
- **border** (str) - Required - The color used for widget borders.
- **inputfg** (str) - Required - The text color for input widgets.
- **inputbg** (str) - Required - The text background color for input widgets.
- **active** (str) - Required - An accent color.
```

--------------------------------

### Start Floodgauge Animation

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/widgets/floodgauge

Initiates the animation for the Floodgauge. For indeterminate mode, it starts a bouncing animation; for determinate mode, it begins auto-incrementing the value. Customizable step size and interval are available.

```python
def start(self, step_size: Optional[int] = None, interval: Optional[int] = None) -> None:
    """Start the progress animation.

    For indeterminate mode, starts the bouncing animation.
    For determinate mode, starts auto-incrementing the value.

    Parameters:
        step_size (int, optional): Amount to increment per animation step.
                                  Defaults to 8 for indeterminate mode,
                                  1 for determinate mode.

        interval (int, optional): Time in milliseconds between animation steps.
                                 Defaults to 20ms for indeterminate mode,
                                 50ms for determinate mode.
    """
    if self.mode == "indeterminate":
        self._step_size = step_size if step_size is not None else 8
        interval = interval if interval is not None else 20
    else:
        self._step_size = step_size if step_size is not None else 1
        interval = interval if interval is not None else 50

    self._running = True
    self._pulse_direction = 1
    self._run_animation(interval)
```

--------------------------------

### DatepickerDialog Initialization

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/dialogs/datepickerdialog

Initializes the DatePickerDialog with optional parameters for parent widget, title, first day of the week, starting date, and styling. The calendar opens to the month containing the start date.

```python
def __init__(self, parent=None, title=' ', firstweekday=6, startdate=None, bootstyle=PRIMARY):
    ... 
```

--------------------------------

### Meter Widget Initialization

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/widgets/meter

Demonstrates how to create and pack a basic Meter widget with common customization options.

```APIDOC
## Meter Widget

### Description
A radial meter that can be used to show progress of long running operations or the amount of work completed. It can also be used as a dial when set to `interactive=True`.

### Parameters

- `metersize` (int) - The overall size of the meter widget.
- `padding` (int) - Padding around the meter widget.
- `amountused` (int) - The current value of the meter.
- `metertype` (str) - The type of meter arc ('full' or 'semi').
- `subtext` (str) - Text displayed below the center label.
- `interactive` (bool) - If True, the meter can be used as a dial.

### Example

```python
import ttkbootstrap as ttk
from ttkbootstrap.constants import *

app = ttk.Window()

meter = ttk.Meter(
    metersize=180,
    padding=5,
    amountused=25,
    metertype="semi",
    subtext="miles per hour",
    interactive=True,
)
meter.pack()

app.mainloop()
```
```

--------------------------------

### Toplevel Initialization

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/window/toplevel

Initialize a Toplevel window with various customization options.

```APIDOC
## Toplevel()

### Description
Initializes a Toplevel window, providing a convenient API with additional features beyond the standard tkinter.Toplevel.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **title** (str) - Optional - The title that appears on the application titlebar. Defaults to "ttkbootstrap".
* **iconphoto** (str) - Optional - A path to the image used for the titlebar icon. Internally passed to `Tk.iconphoto`.
* **size** (tuple[int, int]) - Optional - The width and height of the application window. Internally passed to `Toplevel.geometry`.
* **position** (tuple[int, int]) - Optional - The horizontal and vertical position of the window on the screen. Internally passed to `Toplevel.geometry`.
* **minsize** (tuple[int, int]) - Optional - Specifies the minimum permissible dimensions for the window. Internally passed to `Toplevel.minsize`.
* **maxsize** (tuple[int, int]) - Optional - Specifies the maximum permissible dimensions for the window. Internally passed to `Toplevel.maxsize`.
* **resizable** (tuple[bool, bool]) - Optional - Specifies whether the user may interactively resize the toplevel window for horizontal and vertical dimensions.
* **transient** (tkinter.Misc) - Optional - Instructs the window manager that this widget is transient with regard to the widget master. Internally passed to `Toplevel.transient`.
* **overrideredirect** (bool) - Optional - Instructs the window manager to ignore this widget if True. Internally processed as `Toplevel.overrideredirect(1)`.
* **windowtype** (str) - Optional - On X11, requests that the window should be interpreted by the window manager as being of the specified type. Internally passed to `Toplevel.attributes('-type', windowtype)`.
* **topmost** (bool) - Optional - Makes the window stay on top of other windows.
* **toolwindow** (bool) - Optional - Makes the window a tool window, typically without a maximize button.
* **alpha** (float) - Optional - The transparency level of the window, from 0.0 (fully transparent) to 1.0 (fully opaque). Defaults to 1.0.

### Request Example
```python
app = Toplevel(title="My Toplevel", size=(800, 600), position=(100, 100))
app.mainloop()
```

### Response
#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### items

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/widgets/floodgauge

Get all configuration options as key-value pairs.

```APIDOC
## items()

### Description
Returns an iterator of all configuration options and their current values for the Floodgauge widget.

### Returns
- `dict_items` (Any) - An iterator yielding (option, value) pairs.

### Request Example
```python
config_items = floodgauge.items()
for option, value in config_items:
    print(f"{option}: {value}")
```

### Response Example
```json
{
  "example": "dict_items([('value', '50'), ('maximum', 100), ...])"
}
```
```

--------------------------------

### Font Preview Setup

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/dialogs/fontdialog

Configures the UI elements for font selection, including radio buttons for slant and checkboxes for effects. It also sets up a text widget for live font preview.

```python
slant_lframe = ttk.Labelframe(container, text=MessageCatalog.translate("Slant"), padding=5)
slant_lframe.pack(side=LEFT, fill=X, padx=10, expand=YES)
opt_roman = ttk.Radiobutton(
    master=slant_lframe,
    text=MessageCatalog.translate("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=MessageCatalog.translate("italic"),
    value="italic",
    variable=self._slant,
)
opt_italic.pack(side=LEFT, padx=5, pady=5)

effects_lframe = ttk.Labelframe(container, text=MessageCatalog.translate("Effects"), padding=5)
effects_lframe.pack(side=LEFT, padx=(2, 0), fill=X, expand=YES)
opt_underline = ttk.Checkbutton(
    master=effects_lframe,
    text=MessageCatalog.translate("underline"),
    variable=self._underline,
)
opt_underline.pack(side=LEFT, padx=5, pady=5)
opt_overstrike = ttk.Checkbutton(
    master=effects_lframe,
    text=MessageCatalog.translate("overstrike"),
    variable=self._overstrike,
)
opt_overstrike.pack(side=LEFT, padx=5, pady=5)
```

```python
def _font_preview(self, master: tkinter.Misc, padding: int) -> None:
        container = ttk.Frame(master, padding=padding)
        container.pack(fill=BOTH, expand=YES, anchor=N)

        header = ttk.Label(
            container,
            text=MessageCatalog.translate("Preview"),
            font="TkHeadingFont",
        )
        header.pack(fill=X, pady=2, anchor=N)

        content = MessageCatalog.translate("The quick brown fox jumps over the lazy dog.")
        self._preview_text = ttk.Text(
            master=container,
            height=3,
            font=self._preview_font,
            highlightbackground=self._style.colors.primary,
        )
        self._preview_text.insert(END, content)
        self._preview_text.pack(fill=BOTH, expand=YES)
        container.pack_propagate(False)
```

--------------------------------

### get_date

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/widgets/dateentry

Get the currently selected date from the date picker.

```APIDOC
## get_date()

### Description
Get the currently selected date.

### Returns
- datetime: The currently selected date as a datetime object.
```

--------------------------------

### Launch ttkbootstrap Theme Demo

Source: https://ttkbootstrap.readthedocs.io/en/latest/themes

Run this command in your terminal after installing ttkbootstrap to open a demo window. Use the combobox to select and preview different themes.

```bash
python -m ttkbootstrap
```

--------------------------------

### Get Emoji Categories

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/icons/emoji

Retrieves a set of all available emoji categories.

```APIDOC
## Emoji.categories()

### Description
Get a set of categories.

### Returns
- set: Emoji categories.

### Examples
```python
>>> Emoji.categories()
{'component', 'animal-nature', 'objects', 'symbols', 'flags',
 'people-body', 'smiley-emotion', 'activities', 'food-drink',
 'travel-places'}
```
```

--------------------------------

### Create and Display a Toplevel Window

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/window/toplevel

Instantiate a Toplevel window with a custom title and run its main event loop. This is the basic setup for a ttkbootstrap application window.

```python
app = Toplevel(title="My Toplevel")
app.mainloop()
```

--------------------------------

### Get Style Instance

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/style/style

Returns the singleton instance of the Style class.

```python
@staticmethod
    def get_instance():
        """Returns and instance of the style class"""
        return Style.instance
```

--------------------------------

### Get Style Object

Source: https://ttkbootstrap.readthedocs.io/en/latest/api/window/window

Retrieve a reference to the `ttkbootstrap.style.Style` object associated with the window.

```python
@property
def style(self) -> Style:
        """Return a reference to the `ttkbootstrap.style.Style` object."""
        return self._style
```
Tokens:
Raw