py-simple-ttk 0.1.30

Themes don't have to be hard.

py_simple_ttk 0.1.30

Themes don't have to be hard.

• About
• Requirements
• Configuring ini.json
• The App Object
  • App
• Core Widgets
  • MultiWidgetMixin
  • SuperWidgetMixin
• Tabs
  • Tab
  • LauncherTab
  • BrowserLauncherTab
  • CommandLauncherTab
  • ConsoleTab
  • TableTab
  • TreeTableTab
• Widgets
  • Button Widgets
    • ActiveButton
    • LabeledButton
    • LabeledMultiButton
    • CycleButton
    • LabeledCycleButton
    • LabeledMultiCycleButton
  • Core Functions
    • bbox_to_width_and_height
    • center_window
    • check_in_bounds
    • complex_widget_search
    • copy_to_user_clipboard
    • create_round_rectangle
    • default_pack
    • default_separator
    • default_vertical_pack
    • default_vertical_separator
    • enable_notebook_movement
    • focus_next
    • force_aspect
    • get_asset
    • get_bundled_themes_list
    • get_generated_font_images_lookup
    • get_local_appdata_folder
    • get_themes_folder
    • make_aspect_frames
    • open_link
    • recursive_widget_search
    • run_cl
  • Canvas Widgets
    • ResizableCanvas
    • ScrolledCanvas
    • TiledCanvas
    • ExampleTile
  • Checkbutton Widgets
    • ActiveCheckbutton
    • LabeledCheckbutton
    • LabeledMultiCheckbutton
  • Combobox Widgets
    • ActiveCombobox
    • LabeledCombobox
    • LabeledMultiCombobox
  • Console Widgets
    • ConsoleWidget
  • Constraining Functions
    • check_entry_type
    • check_entry_int
    • check_entry_float
    • check_entry_contents
    • check_entry_ascii_lowercase
    • check_entry_ascii_uppercase
    • check_entry_ascii_letters
    • check_entry_ascii_digits
    • check_entry_ascii_uppercase_digits
    • check_entry_ascii_lowercase_digits
    • check_entry_ascii_hexdigits
    • check_entry_ascii_octdigits
    • check_entry_ascii_letters_digits
    • check_entry_ascii_printable
  • Counter Widgets
    • Counter
    • FloatCounter
    • LabeledCounter
    • LabeledFloatCounter
    • LabeledMultiCounter
    • LabeledMultiFloatCounter
  • Entry Widgets
    • ActiveEntry
    • ScrolledEntry
    • LabeledEntry
    • LabeledMultiEntry
    • LabeledButtonEntry
    • LabeledMultiButtonEntry
    • LabeledPathEntry
    • LabeledMultiPathEntry
    • PasswordEntry
    • LabeledPasswordEntry
    • LabeledMultiPasswordEntry
    • ConstrainedEntry
    • LabeledConstrainedEntry
    • LabeledMultiConstrainedEntry
    • IntEntry
    • LabeledIntEntry
    • LabeledMultiIntEntry
    • FloatEntry
    • LabeledFloatEntry
    • LabeledMultiFloatEntry
    • LowercaseEntry
    • LabeledLowercaseEntry
    • LabeledMultiLowercaseEntry
    • UppercaseEntry
    • LabeledUppercaseEntry
    • LabeledMultiUppercaseEntry
    • LettersEntry
    • LabeledLettersEntry
    • LabeledMultiLettersEntry
    • DigitsEntry
    • LabeledDigitsEntry
    • LabeledMultiDigitsEntry
    • UppercaseDigitsEntry
    • LabeledUppercaseDigitsEntry
    • LabeledMultiUppercaseDigitsEntry
    • LowercaseDigitsEntry
    • LabeledLowercaseDigitsEntry
    • LabeledMultiLowercaseDigitsEntry
    • LettersDigitsEntry
    • LabeledLettersDigitsEntry
    • LabeledMultiLettersDigitsEntry
    • HexdigitsEntry
    • LabeledHexdigitsEntry
    • LabeledMultiHexdigitsEntry
    • OctdigitsEntry
    • LabeledOctdigitsEntry
    • LabeledMultiOctdigitsEntry
    • PrintableEntry
    • LabeledPrintableEntry
    • LabeledMultiPrintableEntry
  • Frame Widgets
    • ColumnFrame
    • HamburgerFrame
  • KeyPad Widgets
    • KeypadButton
    • BaseKeypad
    • DialerKeypad
  • Labeler Widget
    • ActiveButton
    • LabeledButton
    • LabeledMultiButton
    • CycleButton
    • LabeledCycleButton
    • LabeledMultiCycleButton
  • ListBox Widgets
    • ScrolledListBox
    • OrderedListbox
    • Table
  • OptionMenu Widgets
    • ActiveOptionMenu
    • LabeledOptionMenu
    • LabeledMultiOptionMenu
  • ProgressBar Widgets
    • ActiveProgressbar
    • LabeledProgressbar
    • LabeledMultiProgressbar
  • Radiobutton Widgets
    • ActiveRadiobutton
    • RadioTable
    • LabeledRadioTable
    • LabeledMultiRadioTable
    • SimpleRadioTable
    • LabeledSimpleRadioTable
    • LabeledMultiSimpleRadioTable
  • Scale Widgets
    • ActiveScale
    • LabeledScale
    • LabeledMultiScale
  • Spinbox Widgets
    • ActiveSpinbox
    • LabeledSpinbox
    • LabeledMultiSpinbox
  • Text Widgets
    • ScrolledText
    • CopyBox
    • LabeledCopyBox
    • LabeledMultiCopyBox
  • Toplevel Widgets
    • FocusedToplevel
    • NoticeWindow
    • YesNoCancelWindow
    • PromptWindow
    • PasswordWindow
    • ListWindow
  • Misc Widgets
    • ToolTip
    • EasySizegrip
• SuperLib.utils
  • Utils
    • check_if_module_installed
    • check_string_contains
    • dummy_function
    • get_friendly_time
    • get_installed_packages
    • get_unix_timestamp
    • get_unix_timestring
    • get_user_home_folder
    • open_folder_in_explorer
    • sort_dict_by_keys
    • timer_decorator
  • File Generators
    • HTML_Generator
    • TXT_Generator
    • MD_Generator
  • History Mixin
    • HistoryMixin
  • Color Functions
    • reduce_255
    • rgb_to_hex
    • rgba_to_hex
    • hex_to_rgb
    • hex_to_rgba
    • get_gradient
    • rgb_to_scalar
    • scalar_to_rgb
    • linear_gradient
    • get_rainbow
• MegaWidgets
  • Notes MegaWidget
    • NotesTab
  • Conversation MegaWidget
    • ConversationsTab
  • Profile Management
    • ProfilesSystem
    • UserProfile
    • get_profiles_folder
    • get_profiles_list
• Changelog
  • 0.1.30
  • 0.1.29
  • 0.1.28
  • 0.1.27
  • 0.1.26
  • 0.1.25
  • 0.1.24
  • 0.1.23
  • 0.1.22
  • 0.1.21
  • 0.1.20
  • 0.1.19
  • 0.1.18
  • 0.1.17
  • 0.1.16
  • 0.1.15
  • 0.1.14
  • 0.1.13
  • 0.1.12
  • 0.1.11
  • 0.1.10
  • 0.1.9
  • 0.1.8
  • 0.1.7
  • 0.1.6
  • 0.1.5
  • 0.1.4
  • 0.1.3
  • 0.1.2
  • 0.1.1
  • 0.1.0

---

About^

py_simple_ttk exists because I got tired of rewriting the same code over and over for simple projects. The goal is to provide a variety of meta widgets with consistent get/set/enable/disable/destroy methods and mega-widgets that make ttk development easier and faster. Features include built-in theme support, a score of labeled and multi-widgets, tools for easy form building, a sample application demonstrating many of py_simple_ttk's features, a configuration file system, and much more.

Requirements^

Configuring ini.json^

+------------------------+-------------------------------------------+
|        Key             |                   Value                   |
+------------------------+-------------------------------------------+
| application            | Application Name (String)                 |
| version                | Application Version (String)              |
| icon                   | Application Icon Path (String)            |
| width                  | Startup Window Width (Int)                |
| height                 | Startup Window Height (Int)               |
| minwidth               | Window Minimum Width (Int)                |
| minheight              | Window Minimum Height (Int)               |
| scaling                | Window Scaling (Float)                    |
| scale_minsize          | Scale application Minimum Size (Boolean)  |
| scale_startsize        | Scale application Start Size (Boolean)    |
| resizable_width        | Enable Window Width Resizing (Boolean)    |
| resizable_height       | Enable Window Height Resizing (Boolean)   |
| enable_sizegrip        | Enable Window EasySizegrip (Boolean)      |
| start_maximized        | Start Window Maximized (Boolean)          |
| enable_maximized       | Enable Window Maximized (Boolean)         |
| start_fullscreen       | Start Window in Fullscreen mode (Boolean) |
| enable_fullscreen      | Enable Window Fullscreen option (Boolean) |
| ignored_themes         | Themes to not display in menu (List)      |
| enable_themes_menu     | Enable Themes Dropdown (Boolean)          |
| enable_launcher        | Enable Dynamic Launcher System (Boolean)  |
| movable_tabs           | Enable Moveable Notebook Tabs (Boolean)   |
| enable_profiles        | Enable a User Profiles System (Boolean)   |
| conversations_enabled  | Enable Convo System (Boolean)             |
| notes_enabled          | Enable Note System (Boolean)              |
| theme_textboxes        | Apply theme colors to tk.Text (Boolean)   ||
+------------------------+-------------------------------------------+

The App Object^

py_simple_ttk.app.App^

Main Application Object

class App(object):
	def __init__(self, ini_file: str):
		...
	def apply_profile(self, profile: py_simple_ttk.utils.ProfilesSystem.UserProfile):
		"""Apply settings from the current profile. For more complicated profile systems override this function."""
	def copy_to_user_clipboard(self, val: str):
		"""Copys a text val to the user's keyboard"""
	def create_profile(self, name: str = None):
		"""Calling with no name brings up a popup, the popup calls this function again with name kw which instead makes a new profile or asks again for a name if the supplied name was invalid"""
	def select_profile(self, name: str = None):
		"""Calling with no name brings up a popup, the popup calls this function again with the name which instead calls the Profiles System to use a certain profile"""
	def toggle_full_screen(self, event=None):
		"""Toggles full screen."""
	def toggle_maximized(self, event=None):
		"""Toggles maximized window."""
	def update_default_title(self, indicate_profile=True):
		"""Update the window title with the default string, optionally with a profile indicator."""
	def update_title(self, title):
		"""Updates the window title"""
	def use_theme(self, theme: str = None, verbose: bool = False):
		"""Updates the app to use a certain theme."""

Core Widgets^

py_simple_ttk.widgets.MultiWidget.MultiWidgetMixin^

An abstract mixin that provides a way to easily instantiate multiple of the same class of a widget and making complicated forms with simple get/set methods.

MultiWidgets support a simple get/set system. Calling get without a configuration list returns a dict of subwidget keys mapped to the values of each subwidget's .get value. Passing a list of subwidget keys limits MultiWidgetMixin.get to said subwidgets. Subclassing a multiwidget with one or more instances of one class and then calling multiwidget.add() with different classes after is acceptable assuming the widget supports being added and .get / .set / .enable / .disable / .clear methods.

class MultiWidgetMixin(object):
	def __init__(self, widget_type: type, config: dict):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

py_simple_ttk.widgets.SuperWidget.SuperWidgetMixin^

Mixin to easily bind many of the common tkinter events.

This class serves to add bindings for the majority of common tkinter widget events. The bindings are made in add mode to prevent previous / new bindings from causing unintended side-effects like unmapping etc.

class SuperWidgetMixin(object):
	def __init__(self, on_mouse_enter: Callable = None, on_mouse_leave: Callable = None, on_mouse_move: Callable = None, on_mouse_wheel: Callable = None, on_left_click: Callable = None, on_double_left_click: Callable = None, on_middle_click: Callable = None, on_double_middle_click: Callable = None, on_right_click: Callable = None, on_double_right_click: Callable = None, on_configure: Callable = None):
		...

Tabs^

py_simple_ttk.widgets.Tabs.Tab^

The core Tab class.

The notebook object can be any ttk.Notebook, automatically adds itself to its parent notebook with title being the tab label. This class may be instantiated directly and added to or subclassed based on need.

class Tab(Frame):
	def __init__(self, notebook: tkinter.ttk.Notebook, title: str):
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""

py_simple_ttk.widgets.Tabs.LauncherTab^

Basic Tab for launching tasks from a list.

Performs an action on a list of options. The options argument is formatted as such: options = {"Button Text 1": val1,"Button Text 2": val2} Button presses will call action(val)

class LauncherTab(Tab):
	def __init__(self, notebook: tkinter.ttk.Notebook, title: str, options: dict, action: Callable):
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""

py_simple_ttk.widgets.Tabs.BrowserLauncherTab^

LauncherTab that opens a list of URLS/Files

Takes a dict of button texts as keys and urls to open as values

class BrowserLauncherTab(LauncherTab):
	def __init__(self, notebook: tkinter.ttk.Notebook, title: str, options: dict):
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""

py_simple_ttk.widgets.Tabs.CommandLauncherTab^

LauncherTab that runs a list of commands

Takes a dict of button texts as keys and command prompt commands to execute as values

class CommandLauncherTab(LauncherTab):
	def __init__(self, notebook: tkinter.ttk.Notebook, title: str, options: dict):
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""

py_simple_ttk.widgets.Tabs.ConsoleTab^

Basic console tab using a ConsoleWidget

class ConsoleTab(Tab):
	def __init__(self, notebook: tkinter.ttk.Notebook, **kwargs):
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""

py_simple_ttk.widgets.Tabs.TableTab^

Basic Table Tab

table_contents is a dictionary whose keys map to lists of equal lengths with the column contents

class TableTab(Tab):
	def __init__(self, notebook: tkinter.ttk.Notebook, title: str, table_contents: dict, **kw):
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""

py_simple_ttk.widgets.Tabs.TreeTableTab^

Improved Table Tab

table_contents is a dictionary whose keys map to lists of equal lengths with the column contents

class TreeTableTab(Tab):
	def __init__(self, notebook: tkinter.ttk.Notebook, title: str, table_contents: dict = {}, **kw):
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""

Widgets^

Button Widgets^

ActiveButton^

ttk.Button with added features

class ActiveButton(Button, SuperWidgetMixin):
	def __init__(self, parent, default: str = '', command: Callable = None, widgetargs: dict = {}, **kw):
		...
	def clear(self) -> None:
		"""Set button text to default"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def get(self) -> str:
		"""Get button text"""
	def set(self, val: str) -> None:
		"""Set button text"""

LabeledButton^

Labeled ActiveButton widget

class LabeledButton(Labeler, ActiveButton):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, command: str = '', is_child: bool = False, labelside: str = 'left', **kw):
		...
	def clear(self) -> None:
		"""Set button text to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def get(self) -> str:
		"""Get button text"""
	def set(self, val: str) -> None:
		"""Set button text"""

LabeledMultiButton^

Labeled MultiWidget LabeledButton.

Used when you need multiple, vertically stacked Labeled ActiveButtons

class LabeledMultiButton(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

CycleButton^

ActiveButton that cycles through options on each click

class CycleButton(ActiveButton):
	def __init__(self, parent: tkinter.ttk.Frame, options: list, default: int = 0, command: Callable = None, **kw):
		...
	def clear(self, event=None):
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def get(self) -> str:
		"""Get button text"""
	def set(self, val: str) -> None:
		"""Set button text"""

LabeledCycleButton^

Labeled CycleButton widget

class LabeledCycleButton(Labeler, CycleButton):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, options: list, is_child: bool = False, labelside: str = 'left', **kw):
		...
	def clear(self, event=None):
		...
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def get(self) -> str:
		"""Get button text"""
	def set(self, val: str) -> None:
		"""Set button text"""

LabeledMultiCycleButton^

Labeled MultiWidget LabeledCycleButton

Used when you need multiple, vertically stacked Labeled CycleButtons

class LabeledMultiCycleButton(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

Core Functions^

py_simple_ttk.widgets.WidgetsCore.bbox_to_width_and_height^

Takes a bbox and converts it to a width and height tuple.

def bbox_to_width_and_height(bbox: tuple) -> tuple:
> 	...

py_simple_ttk.widgets.WidgetsCore.center_window^

Centers spawn window on main window. Call win.update_idletasks() on either window before calling this if said window is not yet shown.

def center_window(main_window: tkinter.Tk, spawn_window: tkinter.Toplevel) -> None:
> 	...

py_simple_ttk.widgets.WidgetsCore.check_in_bounds^

Checks if a position is within a given bounds. Pos is generally a mouse event position tuple, bounds is generally a canvas.bbox(), but a (left, top, right, bottom) tuple will work too.

def check_in_bounds(pos: tuple, bounds: tuple) -> bool:
> 	...

py_simple_ttk.widgets.WidgetsCore.complex_widget_search^

A more robust version of the widget search with lists for multiple widget types found in one go

def complex_widget_search(node_widget, widget_types_to_find: list, found_lists: dict = {}) -> dict:
> 	...

py_simple_ttk.widgets.WidgetsCore.copy_to_user_clipboard^

Copies a string to the user's clipboard.

def copy_to_user_clipboard(widget, value: str) -> None:
> 	...

py_simple_ttk.widgets.WidgetsCore.create_round_rectangle^

Draws a rounded rectangle of a given radius on a tk.canvas

def create_round_rectangle(canvas, x1: float, y1: float, x2: float, y2: float, r: float = 20, fill: str = '', outline: str = '#000000', **kwargs):
> 	...

py_simple_ttk.widgets.WidgetsCore.default_pack^

Apply a consistent descending packing method.

def default_pack(widget, bottom: bool = False, padx: tuple = 5) -> None:
> 	...

py_simple_ttk.widgets.WidgetsCore.default_separator^

Apply a consistent horizontal separator.

def default_separator(f: tkinter.ttk.Frame, padx: tuple = 35, pady: tuple = (10, 5)) -> tkinter.ttk.Separator:
> 	...

py_simple_ttk.widgets.WidgetsCore.default_vertical_pack^

Apply a consistent packing method to vertically packed widgets.

def default_vertical_pack(widget, expand: bool = False, fill: str = 'both', padx: tuple = 0) -> None:
> 	...

py_simple_ttk.widgets.WidgetsCore.default_vertical_separator^

Apply a consistent vertical separator.

def default_vertical_separator(frame: tkinter.ttk.Frame, pady: tuple = 15, padx: tuple = 10) -> tkinter.ttk.Separator:
> 	...

py_simple_ttk.widgets.WidgetsCore.enable_notebook_movement^

Copyright CJB 2010-07-31: https://wiki.tcl-lang.org/page/Drag+and+Drop+Notebook+Tabs Enables Tab dragging in subsequently created notebooks. Only run this function once.

def enable_notebook_movement(app) -> None:
> 	...

py_simple_ttk.widgets.WidgetsCore.focus_next^

Forces focus to the widget after the one that triggered the event

def focus_next(event) -> object:
> 	...

py_simple_ttk.widgets.WidgetsCore.force_aspect^

Forces an inner frame to maintain an aspect ratio regardless of the outer frame's size

def force_aspect(inner_frame: tkinter.ttk.Frame, outer_frame: tkinter.ttk.Frame, ratio: float = 1.7777777777777777) -> None:
> 	...

py_simple_ttk.widgets.WidgetsCore.get_asset^

Gets an asset from the included assets folder by relative path. Works with pyinstaller.

def get_asset(path, folder: str = 'C:\\Users\\arcti\\github\\py_simple_ttk\\py_simple_ttk\\./assets') -> str:
> 	...

py_simple_ttk.widgets.WidgetsCore.get_bundled_themes_list^

None

def get_bundled_themes_list(verbose: bool = False) -> list:
> 	...

py_simple_ttk.widgets.WidgetsCore.get_generated_font_images_lookup^

Makes a lookup for the pre-generated open-sans font monograms that ship with py_simple_ttk.

def get_generated_font_images_lookup(path: str = None) -> dict:
> 	...

py_simple_ttk.widgets.WidgetsCore.get_local_appdata_folder^

Opens user's Windows home folder. Only works on Windows for obvious reasons.

def get_local_appdata_folder() -> str:
> 	...

py_simple_ttk.widgets.WidgetsCore.get_themes_folder^

Gets the absolute path to the included themes folder

def get_themes_folder() -> str:
> 	...

py_simple_ttk.widgets.WidgetsCore.make_aspect_frames^

Creates an outer and inner frame within a parent frame. Forces the inner frame to maintain an aspect ratio. Returns the outer and inner frames.

def make_aspect_frames(parent: tkinter.ttk.Frame, ratio: float = 1.7777777777777777) -> tuple:
> 	...

py_simple_ttk.widgets.WidgetsCore.open_link^

Opens a link in the user's default web browser. Returns None

def open_link(link: str) -> None:
> 	...

py_simple_ttk.widgets.WidgetsCore.recursive_widget_search^

Adds widgets of a given type to a list as it travels up, away from the root of a widget tree. This method can be slow on large widget trees but is useful for retheming tk widgets with ttk formatting on theme changes. Returns a list of widgets

def recursive_widget_search(node_widget, widget_type_to_find: type, found_list: list = []) -> list:
> 	...

py_simple_ttk.widgets.WidgetsCore.run_cl^

Runs something via command line. Returns None

def run_cl(commands: list) -> None:
> 	...

Canvas Widgets^

py_simple_ttk.widgets.ResizableCanvas.ResizableCanvas^

Resizeable Canvas

Canvas resizes to fit frame on configure event.

class ResizableCanvas(Canvas):
	def __init__(self, parent, **kw):
		...
	def create_arc(self, *args, **kw):
		"""Create arc shaped region with coordinates x1,y1,x2,y2."""
	def create_bitmap(self, *args, **kw):
		"""Create bitmap with coordinates x1,y1."""
	def create_image(self, *args, **kw):
		"""Create image item with coordinates x1,y1."""
	def create_line(self, *args, **kw):
		"""Create line with coordinates x1,y1,...,xn,yn."""
	def create_oval(self, *args, **kw):
		"""Create oval with coordinates x1,y1,x2,y2."""
	def create_polygon(self, *args, **kw):
		"""Create polygon with coordinates x1,y1,...,xn,yn."""
	def create_rectangle(self, *args, **kw):
		"""Create rectangle with coordinates x1,y1,x2,y2."""
	def create_round_rectangle(self, x1: float, y1: float, x2: float, y2: float, r: float = 20, fill: str = '', outline: str = '#000000', **kwargs) -> None:
		"""Draws a rounded rectangle of a given radius on a tk.canvas."""
	def create_text(self, *args, **kw):
		"""Create text with coordinates x1,y1."""
	def create_window(self, *args, **kw):
		"""Create window with coordinates x1,y1,x2,y2."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def refresh(self) -> None:
		"""Refresh Canvas"""

py_simple_ttk.widgets.ScrolledCanvas.ScrolledCanvas^

Resizeable, Auto-Scrollbarred Canvas

Canvas resizes to fit frame on configure event. Canvas has automatic Scrollbars that appear when needed. Canvas background color is based on current theme. Due to how the scrolling is handled the actual Canvas is accessd via ScrolledCanvas().canvas.

class ScrolledCanvas(Frame):
	def __init__(self, parent, on_mouse_enter=None, on_mouse_leave=None, on_mouse_move=None, on_mouse_wheel=None, on_left_click=None, on_middle_click=None, on_right_click=None, on_configure=None, bind_canvas_scroll=True, **kw):
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def get_adjusted_y_view(self, event) -> int:
		"""Gets a canvas y-view adjusted based on its scrolled position"""
	def use_style(self, style) -> None:
		"""Reformat with a given ttk style. `Returns None`"""

py_simple_ttk.widgets.ScrolledCanvas.TiledCanvas^

class TiledCanvas(ScrolledCanvas):
	def __init__(self, *args, tile_width=400, tile_height=100, tile_padx=5, tile_pady=5, tile_color='#424548', text_color='#CCCCCC', border_color='#000000', on_tile_left_click=None, on_tile_middle_click=None, on_tile_right_click=None, override_tile_width=False, **kw):
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def get_adjusted_y_view(self, event) -> int:
		"""Gets a canvas y-view adjusted based on its scrolled position"""
	def refresh(self, event=None) -> None:
		"""Redraw the canvas"""
	def use_style(self, style) -> None:
		"""Reformat with a given ttk style. `Returns None`"""

py_simple_ttk.widgets.ScrolledCanvas.ExampleTile^

An example tile for a Scrolled Canvas

class ExampleTile(object):
	def __init__(self, manager, text: str):
		...
	def activate(self) -> None:
		"""Calls the manager to activate the widget."""
	def deactivate(self) -> None:
		"""Calls the manager to deactivate the widget."""
	def is_in_range(self, pointer_x: float, pointer_y: float) -> bool:
		"""Checks if the mouse pointer is in the tile."""
	def set_position(self, x: float, y: float) -> None:
		"""Sets a tiles position for the draw manager's draw method."""

Checkbutton Widgets^

py_simple_ttk.widgets.CheckbuttonWidgets.ActiveCheckbutton^

ttk.Checkbutton with added features

The "replace_output" keyword argument allows the user to provide a tuple of length 2 to replace the default True/False return values.

class ActiveCheckbutton(Checkbutton):
	def __init__(self, parent: tkinter.ttk.Frame, replace_output: list = None, default: bool = False, **kw):
		...
	def clear(self) -> None:
		"""Sets the Checkbutton to its default value, usually *False* `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Checkbutton. `Returns None`"""
	def enable(self) -> None:
		"""Enable Checkbutton. `Returns None`"""
	def get(self) -> bool:
		"""Get Checkbutton value. `Returns a Boolean unless replace_output is set`"""
	def set(self, val: bool) -> None:
		"""Set Checkbutton value. `Returns None`"""

py_simple_ttk.widgets.CheckbuttonWidgets.LabeledCheckbutton^

Labeled Checkbutton

ActiveCheckbutton with a Label

class LabeledCheckbutton(Labeler, ActiveCheckbutton):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str = '', is_child: bool = False, **kw):
		...
	def clear(self) -> None:
		"""Sets the Checkbutton to its default value, usually *False* `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Checkbutton. `Returns None`"""
	def enable(self) -> None:
		"""Enable Checkbutton. `Returns None`"""
	def get(self) -> bool:
		"""Get Checkbutton value. `Returns a Boolean unless replace_output is set`"""
	def set(self, val: bool) -> None:
		"""Set Checkbutton value. `Returns None`"""

py_simple_ttk.widgets.CheckbuttonWidgets.LabeledMultiCheckbutton^

Labeled MultiWidget LabeledCheckbutton.

Used when you need multiple, vertically stacked Labeled Checkbuttons

class LabeledMultiCheckbutton(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

Combobox Widgets^

py_simple_ttk.widgets.ComboboxWidgets.ActiveCombobox^

ttk.Combobox with added features and the SuperWidgetMixin

class ActiveCombobox(Combobox, SuperWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, command: Callable = None, default: int = 0, on_keystroke: bool = False, bind_enter: bool = True, bind_escape_clear: bool = True, values: list = (), custom_values: bool = True, widgetargs: dict = {}, **kw):
		...
	def clear(self) -> None:
		"""Sets Combobox to its default value. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Combobox. `Returns None`"""
	def enable(self) -> None:
		"""Enable Combobox. `Returns None`"""
	def get(self) -> str:
		"""Get Combobox value. `Returns a String`"""
	def set(self, val: str) -> None:
		"""Set Combobox value. `Returns None`"""

py_simple_ttk.widgets.ComboboxWidgets.LabeledCombobox^

Labeled Combobox with the Super Widget mixin

Set custom_values keyword to "False" to disable custom user-entered values. Set the "default" keyword to the index of the value to display by default from the "values" keyword.

class LabeledCombobox(Labeler, ActiveCombobox):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, labelside: str = 'left', is_child: bool = False, widgetargs={}, **kw):
		...
	def clear(self) -> None:
		"""Sets Combobox to its default value. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Combobox. `Returns None`"""
	def enable(self) -> None:
		"""Enable Combobox. `Returns None`"""
	def get(self) -> str:
		"""Get Combobox value. `Returns a String`"""
	def set(self, val: str) -> None:
		"""Set Combobox value. `Returns None`"""

py_simple_ttk.widgets.ComboboxWidgets.LabeledMultiCombobox^

Labeled MultiWidget LabeledCombobox.

Used when you need mutiple, vertically stacked Labeled Comboboxes

class LabeledMultiCombobox(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

Console Widgets^

py_simple_ttk.widgets.ConsoleWidgets.ConsoleWidget^

Set labeltext, even if temporarily at init or the label widget will be ignored

Used when you need to drop a console interface into an application. To write to the console call console.print(value). Pass a function as the "command" keyword argument to handle the entry input.

class ConsoleWidget(Labeler, Frame):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str = 'Console: ', entrylabeltext: str = 'Command: ', labelside: str = 'top', button_text: str = 'Run', is_child: bool = False, **kwargs):
		...
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def print(self, val, end: str = '\n'):
		"""Prints a line to the console with a customizable line ending. `Returns None`"""

Constraining Functions^

check_entry_type^

Core type checker function. Limits entry to chars that construct a given type

def check_entry_type(val: str, typ: type) -> bool:
> 	...

check_entry_int^

Check if an entry input is a valid integer

def check_entry_int(val: str) -> bool:
> 	...

check_entry_float^

Check if an entry input is a valid float

def check_entry_float(val: str) -> bool:
> 	...

check_entry_contents^

Core content checker function. Limits entry to a list of chars ['a', 'b', 'c', ...] or the chars contained in a simple string 'abc...'

def check_entry_contents(val: str, limiter: list | str) -> bool:
> 	...

check_entry_ascii_lowercase^

Check if entry input is made only of lowercase ascii

def check_entry_ascii_lowercase(val: str) -> bool:
> 	...

check_entry_ascii_uppercase^

Check if entry input is made only of uppercase ascii

def check_entry_ascii_uppercase(val: str) -> bool:
> 	...

check_entry_ascii_letters^

Check if entry input is made only of uppercase and lowercase ascii

def check_entry_ascii_letters(val: str) -> bool:
> 	...

check_entry_ascii_digits^

Check if entry input is made only of digits

def check_entry_ascii_digits(val: str) -> bool:
> 	...

check_entry_ascii_uppercase_digits^

Check if entry input is made only of uppercase ascii and digits

def check_entry_ascii_uppercase_digits(val: str) -> bool:
> 	...

check_entry_ascii_lowercase_digits^

Check if entry input is made only of lowercase ascii and digits

def check_entry_ascii_lowercase_digits(val: str) -> bool:
> 	...

check_entry_ascii_hexdigits^

Check if entry input is made only of hexigits

def check_entry_ascii_hexdigits(val: str) -> bool:
> 	...

check_entry_ascii_octdigits^

Check if entry input is made only of octdigits

def check_entry_ascii_octdigits(val: str) -> bool:
> 	...

check_entry_ascii_letters_digits^

Check if entry input is made only of ascii lowercase, ascii uppercase, and digits

def check_entry_ascii_letters_digits(val) -> bool:
> 	...

check_entry_ascii_printable^

Check if entry input is made only of printable characters

def check_entry_ascii_printable(val: str) -> bool:
> 	...

Counter Widgets^

Counter^

Up / down counter widgets

class Counter(Frame):
	def __init__(self, parent: tkinter.ttk.Frame, default: int = 0, min_value: int = None, max_value: int = None, step: int = 1, state: str = 'normal', command: Callable = None, depth: int = 1, **kwargs):
		...
	def clear(self) -> int:
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		...
	def enable(self) -> None:
		...
	def set(self, val: int, adjust: int = 0, no_command: bool = False) -> int:
		...

FloatCounter^

Float Counter Widget

class FloatCounter(Frame):
	def __init__(self, parent=<class 'tkinter.ttk.Frame'>, default: float = 0.0, min_value: float = None, max_value: float = None, step: float = 1.0, state: str = 'normal', command: Callable = None, decimal_level: int = 1, integer_level: int = 1, **kwargs):
		...
	def clear(self) -> float:
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		...
	def enable(self) -> None:
		...
	def get(self) -> float:
		...
	def set(self, val: float, adjust: float = 0.0) -> float:
		...

LabeledCounter^

Labeled Counter Widget

class LabeledCounter(Labeler, Counter, SuperWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, command: Callable = None, labelside: str = 'left', is_child: bool = False, state: str = 'normal', widgetargs: dict = {}, **kw):
		...
	def clear(self) -> int:
		...
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		...
	def enable(self) -> None:
		...
	def set(self, val: int, adjust: int = 0, no_command: bool = False) -> int:
		...

LabeledFloatCounter^

Labeled Float Counter Widget

class LabeledFloatCounter(Labeler, FloatCounter, SuperWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, command: Callable = None, labelside: str = 'left', is_child: bool = False, state: str = 'normal', widgetargs: dict = {}, **kw):
		...
	def clear(self) -> float:
		...
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		...
	def enable(self) -> None:
		...
	def get(self) -> float:
		...
	def set(self, val: float, adjust: float = 0.0) -> float:
		...

LabeledMultiCounter^

Labeled MultiWidget LabeledCounter.

Used when you need multiple, vertically stacked Labeled Counters

class LabeledMultiCounter(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

LabeledMultiFloatCounter^

Labeled MultiWidget Labeled FloatCounter.

Used when you need multiple, vertically stacked Labeled FloatCounters

class LabeledMultiFloatCounter(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

Entry Widgets^

py_simple_ttk.widgets.EntryWidgets.ActiveEntry^

Active ttk.Entry with added features and the SuperWidgetMixin

class ActiveEntry(Entry, SuperWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, command: Callable = None, default: str = '', on_keystroke: bool = False, bind_enter: bool = True, bind_escape_clear: bool = True, widgetargs: dict = {}, **kw):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> str:
		"""Get Entry value. `Returns a String`"""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.EntryWidgets.ScrolledEntry^

Scrolled ttk.Entry with SuperWidgetMixin

This class is here for completeness but most of the time you will want to use the ScrolledText widget. Used when you need a scrollable text entry box.

class ScrolledEntry(Scroller, ActiveEntry):
	def __init__(self, parent, **kw) -> object:
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> str:
		"""Get Entry value. `Returns a String`"""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.EntryWidgets.LabeledEntry^

Labeled ActiveEntry

ActiveEntry with Label

class LabeledEntry(Labeler, ActiveEntry):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, labelside: str = 'left', is_child: bool = False, **kw):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> str:
		"""Get Entry value. `Returns a String`"""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.EntryWidgets.LabeledMultiEntry^

Labeled MultiWidget LabeledEntry

Used when you need multiple, vertically stacked Labeled Entries

class LabeledMultiEntry(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

py_simple_ttk.widgets.EntryWidgets.LabeledButtonEntry^

LabeledEntry with a ttk.Button on the right

class LabeledButtonEntry(LabeledEntry):
	def __init__(self, *args, button_text='', **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> str:
		"""Get Entry value. `Returns a String`"""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.EntryWidgets.LabeledMultiButtonEntry^

Labeled MultiWidget Labeled ButtonEntry

Used when you need multiple, vertically stacked Labeled Entries

class LabeledMultiButtonEntry(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

py_simple_ttk.widgets.EntryWidgets.LabeledPathEntry^

LabeledEntry with a ttk.Button bound to a file- or folder-picker for easy system path selection. Defaults to tk.filedialog.askopenfilename if no tk.filedialog specified.

class LabeledPathEntry(LabeledEntry):
	def __init__(self, *args, button_text: str = '...', dialog=None, dialog_args: dict = {}, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> str:
		"""Get Entry value. `Returns a String`"""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.EntryWidgets.LabeledMultiPathEntry^

Labeled MultiWidget LabeledPathEntry

Used when you need multiple, vertically stacked LabeledPathEntries

class LabeledMultiPathEntry(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

py_simple_ttk.widgets.EntryWidgets.PasswordEntry^

Username / Password Entry

A username/password entry widget with optional password peeking. Set password_char to '' to show password by default. The provided command will always be called with the tuple (username_entry.get(), password_entry.get()) as the only argument even if one of the entries is disabled.

class PasswordEntry(Frame):
	def __init__(self, *args, instruction_text: str = '', username_text: str = 'Username: ', username_enabled: bool = True, password_text: str = 'Password: ', password_enabled: bool = True, button_text: str = 'Submit', command=<built-in function print>, password_char: str = '*', peek_enabled: bool = True, invert_peek_colors: bool = False, **kwargs):
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def get(self) -> tuple:
		...
	def set(self, values: tuple) -> None:
		...

py_simple_ttk.widgets.EntryWidgets.LabeledPasswordEntry^

Labeled Username/Password entry

class LabeledPasswordEntry(Labeler, PasswordEntry):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, *args, is_child: bool = False, **kw):
		...
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def get(self) -> tuple:
		...
	def set(self, values: tuple) -> None:
		...

py_simple_ttk.widgets.EntryWidgets.LabeledMultiPasswordEntry^

Labeled MultiWidget Labeled PasswordEntry

Used when you need multiple, vertically stacked Labeled Username/Password Entries

class LabeledMultiPasswordEntry(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.ConstrainedEntry^

Constrained ActiveEntry

An Entry widget that allows certain constraints to be placed on the input with a given check_function that returns true if the input is allowed for each keystroke / input.

class ConstrainedEntry(ActiveEntry):
	def __init__(self, parent: tkinter.ttk.Frame, check_function: Callable, return_type: type = <class 'str'>, **kw):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledConstrainedEntry^

Labeled Constrained Entry

class LabeledConstrainedEntry(Labeler, ConstrainedEntry):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, *args, is_child: bool = False, **kw):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledMultiConstrainedEntry^

Labeled Multi Constrained Entry

class LabeledMultiConstrainedEntry(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.IntEntry^

Int Entry Widget

class IntEntry(ConstrainedEntry):
	def __init__(self, parent, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledIntEntry^

Labeled Int Entry Widget

class LabeledIntEntry(LabeledConstrainedEntry):
	def __init__(self, parent, labeltext, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledMultiIntEntry^

class LabeledMultiIntEntry(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.FloatEntry^

class FloatEntry(ConstrainedEntry):
	def __init__(self, parent, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledFloatEntry^

class LabeledFloatEntry(LabeledConstrainedEntry):
	def __init__(self, parent, labeltext, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledMultiFloatEntry^

class LabeledMultiFloatEntry(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LowercaseEntry^

class LowercaseEntry(ConstrainedEntry):
	def __init__(self, parent, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledLowercaseEntry^

class LabeledLowercaseEntry(LabeledConstrainedEntry):
	def __init__(self, parent, labeltext, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledMultiLowercaseEntry^

class LabeledMultiLowercaseEntry(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.UppercaseEntry^

class UppercaseEntry(ConstrainedEntry):
	def __init__(self, parent, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledUppercaseEntry^

class LabeledUppercaseEntry(LabeledConstrainedEntry):
	def __init__(self, parent, labeltext, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledMultiUppercaseEntry^

class LabeledMultiUppercaseEntry(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LettersEntry^

class LettersEntry(ConstrainedEntry):
	def __init__(self, parent, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledLettersEntry^

class LabeledLettersEntry(LabeledConstrainedEntry):
	def __init__(self, parent, labeltext, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledMultiLettersEntry^

class LabeledMultiLettersEntry(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.DigitsEntry^

class DigitsEntry(ConstrainedEntry):
	def __init__(self, parent, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledDigitsEntry^

class LabeledDigitsEntry(LabeledConstrainedEntry):
	def __init__(self, parent, labeltext, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledMultiDigitsEntry^

class LabeledMultiDigitsEntry(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.UppercaseDigitsEntry^

class UppercaseDigitsEntry(ConstrainedEntry):
	def __init__(self, parent, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledUppercaseDigitsEntry^

class LabeledUppercaseDigitsEntry(LabeledConstrainedEntry):
	def __init__(self, parent, labeltext, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledMultiUppercaseDigitsEntry^

class LabeledMultiUppercaseDigitsEntry(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LowercaseDigitsEntry^

class LowercaseDigitsEntry(ConstrainedEntry):
	def __init__(self, parent, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledLowercaseDigitsEntry^

class LabeledLowercaseDigitsEntry(LabeledConstrainedEntry):
	def __init__(self, parent, labeltext, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledMultiLowercaseDigitsEntry^

class LabeledMultiLowercaseDigitsEntry(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LettersDigitsEntry^

class LettersDigitsEntry(ConstrainedEntry):
	def __init__(self, parent, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledLettersDigitsEntry^

class LabeledLettersDigitsEntry(LabeledConstrainedEntry):
	def __init__(self, parent, labeltext, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledMultiLettersDigitsEntry^

class LabeledMultiLettersDigitsEntry(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.HexdigitsEntry^

class HexdigitsEntry(ConstrainedEntry):
	def __init__(self, parent, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledHexdigitsEntry^

class LabeledHexdigitsEntry(LabeledConstrainedEntry):
	def __init__(self, parent, labeltext, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledMultiHexdigitsEntry^

class LabeledMultiHexdigitsEntry(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.OctdigitsEntry^

class OctdigitsEntry(ConstrainedEntry):
	def __init__(self, parent, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledOctdigitsEntry^

class LabeledOctdigitsEntry(LabeledConstrainedEntry):
	def __init__(self, parent, labeltext, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledMultiOctdigitsEntry^

class LabeledMultiOctdigitsEntry(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.PrintableEntry^

class PrintableEntry(ConstrainedEntry):
	def __init__(self, parent, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledPrintableEntry^

class LabeledPrintableEntry(LabeledConstrainedEntry):
	def __init__(self, parent, labeltext, *args, **kwargs):
		...
	def clear(self) -> None:
		"""Set Entry value to default, empty unless default set. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Entry. `Returns None`"""
	def enable(self) -> None:
		"""Enable Entry. `Returns None`"""
	def get(self) -> object:
		"""Get Entry value, return type varies based on Entry constraint."""
	def set(self, val) -> None:
		"""Set Entry value. `Returns None`"""

py_simple_ttk.widgets.ConstrainedEntryWidgets.LabeledMultiPrintableEntry^

class LabeledMultiPrintableEntry(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

Frame Widgets^

py_simple_ttk.widgets.FrameWidgets.ColumnFrame^

A frame with a given number of children column frames

class ColumnFrame(Frame):
	def __init__(self, parent: tkinter.ttk.Frame, columns: int = 1, pack_args: dict = {}, **kw):
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def yield_frame(self):
		"""Cyclically returns frames"""

py_simple_ttk.widgets.FrameWidgets.HamburgerFrame^

A ttk.Frame with a Hamburger Menu and supporting widgets

Options is an iterable in the form ((label, callback), (label2, callback2), ...). See examples/hamburger_demo.py for usage.

class HamburgerFrame(Frame):
	def __init__(self, parent: tkinter.ttk.Frame, options: collections.abc.Iterable, menu_width: int = 300, column_style='Hamburger.TFrame', **kw):
		...
	def close(self, event=None) -> None:
		"""Closes the menu. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def open(self, event=None) -> None:
		"""Opens the menu. `Returns None`"""

KeyPad Widgets^

py_simple_ttk.widgets.KeyPadWidgets.KeypadButton^

Base Keypad Button

Keypad button that automatically packs itself based on given coordinates. This object is not usually directly instantiated.

class KeypadButton(Button):
	def __init__(self, frame: tkinter.ttk.Frame, value: int, coords: tuple, command: Callable):
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""

py_simple_ttk.widgets.KeyPadWidgets.BaseKeypad^

Base Keypad Class

Either instantiate directly with a custom layout or subclass with each subclass supplying a custom layout for more keypads. Subclass KeypadButton and supply the class as the "button_type" kwarg for custom buttons.

class BaseKeypad(Frame):
	def __init__(self, layout, command, button_class=<class 'py_simple_ttk.widgets.KeyPadWidgets.KeypadButton'>, *args, **kwargs):
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""

py_simple_ttk.widgets.KeyPadWidgets.DialerKeypad^

Phone Dialer Keypad

Example 12-button keypad, subclass BaseKeypad and supply a custom layout for more keypads.

class DialerKeypad(BaseKeypad):
	def __init__(self, command: Callable, *args, **kwargs):
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""

Labeler Widget^

ActiveButton^

ttk.Button with added features

class ActiveButton(Button, SuperWidgetMixin):
	def __init__(self, parent, default: str = '', command: Callable = None, widgetargs: dict = {}, **kw):
		...
	def clear(self) -> None:
		"""Set button text to default"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def get(self) -> str:
		"""Get button text"""
	def set(self, val: str) -> None:
		"""Set button text"""

LabeledButton^

Labeled ActiveButton widget

class LabeledButton(Labeler, ActiveButton):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, command: str = '', is_child: bool = False, labelside: str = 'left', **kw):
		...
	def clear(self) -> None:
		"""Set button text to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def get(self) -> str:
		"""Get button text"""
	def set(self, val: str) -> None:
		"""Set button text"""

LabeledMultiButton^

Labeled MultiWidget LabeledButton.

Used when you need multiple, vertically stacked Labeled ActiveButtons

class LabeledMultiButton(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

CycleButton^

ActiveButton that cycles through options on each click

class CycleButton(ActiveButton):
	def __init__(self, parent: tkinter.ttk.Frame, options: list, default: int = 0, command: Callable = None, **kw):
		...
	def clear(self, event=None):
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def get(self) -> str:
		"""Get button text"""
	def set(self, val: str) -> None:
		"""Set button text"""

LabeledCycleButton^

Labeled CycleButton widget

class LabeledCycleButton(Labeler, CycleButton):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, options: list, is_child: bool = False, labelside: str = 'left', **kw):
		...
	def clear(self, event=None):
		...
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def get(self) -> str:
		"""Get button text"""
	def set(self, val: str) -> None:
		"""Set button text"""

LabeledMultiCycleButton^

Labeled MultiWidget LabeledCycleButton

Used when you need multiple, vertically stacked Labeled CycleButtons

class LabeledMultiCycleButton(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

ListBox Widgets^

py_simple_ttk.widgets.ListBoxWidgets.ScrolledListBox^

Scrolled Listbox with SuperWidget mixin

class ScrolledListBox(Scroller, Listbox, SuperWidgetMixin):
	def __init__(self, parent, **kw) -> object:
		...
	def activate(self, index):
		"""Activate item identified by INDEX."""
	def curselection(self):
		"""Return the indices of currently selected item."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def get(self, first, last=None):
		"""Get list of items from FIRST to LAST (included)."""

py_simple_ttk.widgets.ListBoxWidgets.OrderedListbox^

A Scrolled Re-Orderable Listbox with SuperWidget mixin

Used when you need a re-orderable listbox for list arrangement etc. "selectmode" can only be "single" for this Widget.

class OrderedListbox(ScrolledListBox):
	def __init__(self, parent: tkinter.ttk.Frame, **kw):
		...
	def activate(self, index):
		"""Activate item identified by INDEX."""
	def curselection(self):
		"""Return the indices of currently selected item."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def get(self, first, last=None):
		"""Get list of items from FIRST to LAST (included)."""

py_simple_ttk.widgets.ListBoxWidgets.Table^

Listboxes bound to scroll in union. Additional bindings will be needed in order to handle clicking.

Tested on Mac/Windows/Linux. In most cases a TreeTable widget will be superior to this.

class Table(Frame):
	def __init__(self, *args, min_column_width: int = 100, start_column_width: int = 100, on_selection: Callable = None, visible_rows=0, **kw):
		...
	def build(self, contents: dict) -> None:
		"""Rebuild the table"""
	def clear(self) -> None:
		"""Clears the table"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def get(self) -> list:
		"""Gets the currently selected items from the table. `Returns a List of Strings`"""
	def use_style(self, style: tkinter.ttk.Style) -> None:
		"""Update to match supplied ttk.Style object. `Returns None`"""

OptionMenu Widgets^

py_simple_ttk.widgets.OptionMenuWidgets.ActiveOptionMenu^

ttk.OptionMenu with added features and SuperWidgetMixin

class ActiveOptionMenu(OptionMenu, SuperWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, options: list, default: int = 0, on_keystroke: bool = False, bind_enter: bool = True, bind_escape_clear: bool = True, command: Callable = None, widgetargs: dict = {}):
		...
	def clear(self) -> None:
		"""Sets OptionMenu to its default value. `Returns None`"""
	def destroy(self):
		"""Destroy this widget and its associated variable."""
	def disable(self) -> None:
		"""Disable OptionMenu. `Returns None`"""
	def enable(self) -> None:
		"""Enable OptionMenu. `Returns None`"""
	def get(self) -> str:
		"""Get OptionMenu value. `Returns a String`"""
	def set(self, val) -> None:
		"""Set OptionMenu value. `Returns None`"""
	def set_menu(self, default=None, *values):
		"""Build a new menu of radiobuttons with *values and optionally
        a default value."""

py_simple_ttk.widgets.OptionMenuWidgets.LabeledOptionMenu^

Labeled ActiveOptionMenu

class LabeledOptionMenu(Labeler, ActiveOptionMenu):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, *args, is_child: bool = False, **kw):
		...
	def clear(self) -> None:
		"""Sets OptionMenu to its default value. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this widget and its associated variable."""
	def disable(self) -> None:
		"""Disable OptionMenu. `Returns None`"""
	def enable(self) -> None:
		"""Enable OptionMenu. `Returns None`"""
	def get(self) -> str:
		"""Get OptionMenu value. `Returns a String`"""
	def set(self, val) -> None:
		"""Set OptionMenu value. `Returns None`"""
	def set_menu(self, default=None, *values):
		"""Build a new menu of radiobuttons with *values and optionally
        a default value."""

py_simple_ttk.widgets.OptionMenuWidgets.LabeledMultiOptionMenu^

Labeled MultiWidget LabeledOptionMenu

class LabeledMultiOptionMenu(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

ProgressBar Widgets^

py_simple_ttk.widgets.ProgressbarWidgets.ActiveProgressbar^

ttk.Progressbar with added features

class ActiveProgressbar(Progressbar):
	def __init__(self, parent: tkinter.ttk.Frame, default: float = 0, **kw):
		...
	def clear(self):
		"""Sets Progressbar progress to its default value `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self):
		"""Enable Progressbar. `Returns None`"""
	def enable(self):
		"""Disable Progressbar. `Returns None`"""
	def get(self):
		"""Set Progressbar progress. `Returns None`"""
	def link(self, widget):
		"""Easily link to other widgets, sets the progressbar var to the passed widget's var. `Returns None`"""
	def set(self, val):
		"""Get Progressbar progress. `Returns a String`"""
	def start(self, interval=None):
		"""Begin autoincrement mode: schedules a recurring timer event
        that calls method step every interval milliseconds.

        interval defaults to 50 milliseconds (20 steps/second) if omitted."""
	def step(self, amount=None):
		"""Increments the value option by amount.

        amount defaults to 1.0 if omitted."""
	def stop(self):
		"""Stop autoincrement mode: cancels any recurring timer event
        initiated by start."""

py_simple_ttk.widgets.ProgressbarWidgets.LabeledProgressbar^

Labeled Progressbar

class LabeledProgressbar(Labeler, ActiveProgressbar):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, orient='horizontal', labelside='left', is_child=False, default: float = 0, **kw):
		...
	def clear(self):
		"""Sets Progressbar progress to its default value `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self):
		"""Enable Progressbar. `Returns None`"""
	def enable(self):
		"""Disable Progressbar. `Returns None`"""
	def get(self):
		"""Set Progressbar progress. `Returns None`"""
	def link(self, widget):
		"""Easily link to other widgets, sets the progressbar var to the passed widget's var. `Returns None`"""
	def set(self, val):
		"""Get Progressbar progress. `Returns a String`"""
	def start(self, interval=None):
		"""Begin autoincrement mode: schedules a recurring timer event
        that calls method step every interval milliseconds.

        interval defaults to 50 milliseconds (20 steps/second) if omitted."""
	def step(self, amount=None):
		"""Increments the value option by amount.

        amount defaults to 1.0 if omitted."""
	def stop(self):
		"""Stop autoincrement mode: cancels any recurring timer event
        initiated by start."""

py_simple_ttk.widgets.ProgressbarWidgets.LabeledMultiProgressbar^

Labeled MultiWidget LabeledProgressbar

class LabeledMultiProgressbar(Labeler, Frame, MultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside='top', orient='horizontal'):
		...
	def add(self, parent: tkinter.ttk.Frame, key: str, args, kwargs, widget_type=None) -> object:
		"""Overrides normal MultiWidgetMixin behavior to deal with vertical orientation. Will break most added widgets  `Returns None`"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def link(self, config: dict) -> None:
		"""Link to other widgets with a dict of subwidget keys to link to. This function will break if widgets without the link method are added to the MultiWidget. `Returns None`"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

Radiobutton Widgets^

py_simple_ttk.widgets.RadiobuttonWidgets.ActiveRadiobutton^

ttk.Radiobutton with added features and the SuperWidgetMixin

class ActiveRadiobutton(Radiobutton, SuperWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, text: str, value: str, variable: tkinter.StringVar | tkinter.IntVar | tkinter.DoubleVar, widgetargs: dict = {}, **kw):
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		...
	def enable(self) -> None:
		...
	def get(self) -> bool:
		"""`Returns a bool if the button is clicked`"""
	def set(self, val: str | int | float) -> None:
		"""Set value, input type varies base on tk variable type. `Returns None`"""

py_simple_ttk.widgets.RadiobuttonWidgets.RadioTable^

A table of ttk.RadioButtons

class RadioTable(Frame):
	def __init__(self, parent: tkinter.ttk.Frame, options: tuple, default: int = 0, variable_type: type = <class 'tkinter.StringVar'>, state: str = 'normal', columns: int = 1, pack_args: dict = {}, **kw):
		...
	def clear(self) -> None:
		"""Sets Radiobutton to its default value. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Enable Radiobutton. `Returns None`"""
	def enable(self) -> None:
		"""Disable Radiobutton. `Returns None`"""
	def get(self) -> str:
		"""Get Radiobutton value. `Returns a String`"""
	def set(self, val: str) -> None:
		"""Set Radiobutton value. `Returns None`"""

py_simple_ttk.widgets.RadiobuttonWidgets.LabeledRadioTable^

Labeled RadioTable widget

class LabeledRadioTable(Labeler, RadioTable):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def clear(self) -> None:
		"""Sets Radiobutton to its default value. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Enable Radiobutton. `Returns None`"""
	def enable(self) -> None:
		"""Disable Radiobutton. `Returns None`"""
	def get(self) -> str:
		"""Get Radiobutton value. `Returns a String`"""
	def set(self, val: str) -> None:
		"""Set Radiobutton value. `Returns None`"""

py_simple_ttk.widgets.RadiobuttonWidgets.LabeledMultiRadioTable^

Labeled MultiWidget LabeledRadioTable

Used when you need multiple, vertically stacked LabeledRadioTables

class LabeledMultiRadioTable(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

py_simple_ttk.widgets.RadiobuttonWidgets.SimpleRadioTable^

A simplified RadioTable where the text is used at the value.

Uses a tk.StringVar variable type only. Takes a tuple in the form (value1, value2, ...)

class SimpleRadioTable(RadioTable):
	def __init__(self, parent: tkinter.ttk.Frame, options: tuple, **kw):
		...
	def clear(self) -> None:
		"""Sets Radiobutton to its default value. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Enable Radiobutton. `Returns None`"""
	def enable(self) -> None:
		"""Disable Radiobutton. `Returns None`"""
	def get(self) -> str:
		"""Get Radiobutton value. `Returns a String`"""
	def set(self, val: str) -> None:
		"""Set Radiobutton value. `Returns None`"""

py_simple_ttk.widgets.RadiobuttonWidgets.LabeledSimpleRadioTable^

Labeled SimpleRadioTable widget

class LabeledSimpleRadioTable(Labeler, SimpleRadioTable):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, options: list, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def clear(self) -> None:
		"""Sets Radiobutton to its default value. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Enable Radiobutton. `Returns None`"""
	def enable(self) -> None:
		"""Disable Radiobutton. `Returns None`"""
	def get(self) -> str:
		"""Get Radiobutton value. `Returns a String`"""
	def set(self, val: str) -> None:
		"""Set Radiobutton value. `Returns None`"""

py_simple_ttk.widgets.RadiobuttonWidgets.LabeledMultiSimpleRadioTable^

Labeled MultiWidget LabeledSimpleRadioTable

Used when you need multiple, vertically stacked LabeledSimpleRadioTables

class LabeledMultiSimpleRadioTable(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

Scale Widgets^

py_simple_ttk.widgets.ScaleWidgets.ActiveScale^

ttk.Scale with added features and the SuperWidget mixin

class ActiveScale(Scale, SuperWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, command: Callable = None, default: float = 0, widgetargs: dict = {}, **kw):
		...
	def clear(self) -> None:
		"""Sets Scale to its default value. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Enable Scale. `Returns None`"""
	def enable(self) -> None:
		"""Disable Scale. `Returns None`"""
	def get(self) -> float:
		"""Get Scale value. `Returns a Float`"""
	def set(self, val: float) -> None:
		"""Set Scale value. `Returns None`"""

py_simple_ttk.widgets.ScaleWidgets.LabeledScale^

Labeled ActiveScale

class LabeledScale(Labeler, ActiveScale):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, command: Callable = None, orient: bool = 'horizontal', is_child: bool = False, labelside: str = 'left', **kw):
		...
	def clear(self) -> None:
		"""Sets Scale to its default value. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Enable Scale. `Returns None`"""
	def enable(self) -> None:
		"""Disable Scale. `Returns None`"""
	def get(self) -> float:
		"""Get Scale value. `Returns a Float`"""
	def set(self, val: float) -> None:
		"""Set Scale value. `Returns None`"""

py_simple_ttk.widgets.ScaleWidgets.LabeledMultiScale^

Labeled MultiWidget Labeled Scale

class LabeledMultiScale(Labeler, Frame, MultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside='top', orient='horizontal', command=None):
		...
	def add(self, parent: tkinter.ttk.Frame, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Override MultiWidgetMixin for vertical orientation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

Spinbox Widgets^

ActiveSpinbox^

Spinbox with added features

class ActiveSpinbox(Spinbox, SuperWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, command: Callable = None, default: int = 0, on_keystroke: bool = False, bind_enter: bool = True, bind_escape_clear: bool = True, bind_mouse_wheel: bool = True, custom_values: bool = True, widgetargs: dict = {}, **kw):
		...
	def clear(self) -> None:
		"""Sets Spinbox to its default value. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Spinbox. `Returns None`"""
	def enable(self) -> None:
		"""Enable Spinbox. `Returns None`"""
	def get(self) -> int:
		"""Get Spinbox value. `Returns an Int`"""
	def set(self, val: int) -> None:
		"""Set Spinbox value. `Returns None`"""

LabeledSpinbox^

Labeled Spinbox with the SuperWidget mixin

class LabeledSpinbox(Labeler, ActiveSpinbox):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, labelside: str = 'left', is_child: bool = False, **kw):
		...
	def clear(self) -> None:
		"""Sets Spinbox to its default value. `Returns None`"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable Spinbox. `Returns None`"""
	def enable(self) -> None:
		"""Enable Spinbox. `Returns None`"""
	def get(self) -> int:
		"""Get Spinbox value. `Returns an Int`"""
	def set(self, val: int) -> None:
		"""Set Spinbox value. `Returns None`"""

LabeledMultiSpinbox^

Labeled MultiWidget Spinbox.

Used when you need multiple, vertically stacked Labeled Spinboxes

class LabeledMultiSpinbox(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

Text Widgets^

py_simple_ttk.widgets.TextWidgets.ScrolledText^

Scrolled Text with SuperWidget mixin

Scrolled Text SuperWidget

class ScrolledText(Scroller, Text, SuperWidgetMixin):
	def __init__(self, parent, **kw) -> object:
		...
	def clear(self) -> None:
		"""Empties the text box. `Returns None`"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		...
	def edit_undo(self):
		"""Undoes the last edit action

        If the undo option is true. An edit action is defined
        as all the insert and delete commands that are recorded
        on the undo stack in between two separators. Generates
        an error when the undo stack is empty. Does nothing
        when the undo option is false
        """
	def enable(self) -> None:
		"""Enable Text box"""
	def get(self, start: str = '1.0', end: str = 'end'):
		"""Returns the contents of the text box with optional start/end kwargs. `Returns a String`"""
	def get_cursor(self):
		"""Get the current location of the cursor. `Returns None`"""
	def select_all(self, event=None) -> None:
		"""Selects all text. `Returns None`"""
	def set(self, val: str) -> None:
		"""Sets the text. `Returns a String`"""
	def window_create(self, index, cnf={}, **kw):
		"""Create a window at INDEX."""

py_simple_ttk.widgets.TextWidgets.CopyBox^

Scrolled Text with "Copy to Clipboard" Button

A widget with a scrolled textbox and button that copies the textbox contents to the user's clipboard. Useful for form output, etc.

class CopyBox(Frame):
	def __init__(self, parent: tkinter.ttk.Frame, **kw):
		...
	def clear(self) -> None:
		"""Clear CopyBox Contents"""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable CopyBox"""
	def enable(self) -> None:
		"""Enable CopyBox"""
	def get(self) -> None:
		"""Get CopyBox contents"""
	def set(self, val: str) -> None:
		"""Set CopyBox Contents"""

py_simple_ttk.widgets.TextWidgets.LabeledCopyBox^

Labeled CopyBox widget

class LabeledCopyBox(Labeler, CopyBox):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, is_child: bool = False, labelside: str = 'left', **kw):
		...
	def clear(self) -> None:
		"""Clear CopyBox Contents"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self) -> None:
		"""Disable CopyBox"""
	def enable(self) -> None:
		"""Enable CopyBox"""
	def get(self) -> None:
		"""Get CopyBox contents"""
	def set(self, val: str) -> None:
		"""Set CopyBox Contents"""

py_simple_ttk.widgets.TextWidgets.LabeledMultiCopyBox^

Labeled MultiWidget CopyBox.

Used when you need multiple, vertically stacked Labeled CopyBoxes

class LabeledMultiCopyBox(LabeledMultiWidgetMixin):
	def __init__(self, parent: tkinter.ttk.Frame, labeltext: str, config: dict, is_child: bool = False, labelside: str = 'top', **kw):
		...
	def add(self, parent, key: str, args: list, kwargs: dict, widget_type: type = None) -> object:
		"""Method for adding different widgets to a multiwidget post-instantiation"""
	def clear(self, config: list = None) -> None:
		"""Pass a list of subwidgets to clear or all are set to default"""
	def clear_label_text(self) -> None:
		"""Clear a Labeled widget's Label text."""
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to disable or all are disabled"""
	def enable(self, config: list = None) -> None:
		"""Pass a list of subwidgets to enable or all are enabled"""
	def get(self, config: list = None) -> dict:
		"""Pass a list of widget keys to get a dict of outputs"""
	def set(self, config: dict) -> None:
		"""Pass a map of widget keys and their values"""

Toplevel Widgets^

py_simple_ttk.widgets.ToplevelWidgets.FocusedToplevel^

Base Focused Toplevel Class

Window that takes focus and center's itself on the current window. Used as a base class for other windows.

class FocusedToplevel(Toplevel):
	def __init__(self, *args, title: str = None, window: tkinter.Toplevel = None, on_close: Callable = None, **kwargs):
		...
	def destroy(self) -> None:
		...
	def iconify(self):
		"""Display widget as icon."""
	def iconmask(self, bitmap=None):
		"""Set mask for the icon bitmap of this widget. Return the
        mask if None is given."""

py_simple_ttk.widgets.ToplevelWidgets.NoticeWindow^

Provides the user with a notice.

button_action can call a function to help with determining acceptance vs. the user hitting the exit button.

class NoticeWindow(FocusedToplevel):
	def __init__(self, *args, text: str = None, button_text: str = 'Continue', button_action: Callable = None, **kwargs):
		...
	def destroy(self) -> None:
		...
	def iconify(self):
		"""Display widget as icon."""
	def iconmask(self, bitmap=None):
		"""Set mask for the icon bitmap of this widget. Return the
        mask if None is given."""

py_simple_ttk.widgets.ToplevelWidgets.YesNoCancelWindow^

Provides the user with a yes/no/cancel option.

no_destroy can be set to True to allow the window to remain open after a selection is made.

class YesNoCancelWindow(FocusedToplevel):
	def __init__(self, *args, text: str = None, yes_enabled: bool = True, on_yes: Callable = None, yes_text: str = 'Yes', no_enabled: bool = True, on_no: Callable = None, no_text: str = 'No', cancel_enabled: bool = True, on_cancel: Callable = None, cancel_text: str = 'Cancel', no_destroy: bool = False, focus: str = '', **kwargs):
		...
	def destroy(self) -> None:
		...
	def iconify(self):
		"""Display widget as icon."""
	def iconmask(self, bitmap=None):
		"""Set mask for the icon bitmap of this widget. Return the
        mask if None is given."""

py_simple_ttk.widgets.ToplevelWidgets.PromptWindow^

Prompts the user for a text input

no_destroy can be set to True to allow the window to remain open after a selection is made, useful for informing the user a string input was invalid via setting label_var. If the select_type kwarg is set to true the user will be prompted to select a data type (int / string) to return.

class PromptWindow(FocusedToplevel):
	def __init__(self, *args, text: str = 'Enter Text:', on_yes=None, yes_text: str = 'Continue', on_cancel=None, cancel_text: str = 'Cancel', bind_enter: bool = True, no_destroy: bool = False, select_type: bool = False, focus='', **kwargs):
		...
	def destroy(self) -> None:
		...
	def iconify(self):
		"""Display widget as icon."""
	def iconmask(self, bitmap=None):
		"""Set mask for the icon bitmap of this widget. Return the
        mask if None is given."""

py_simple_ttk.widgets.ToplevelWidgets.PasswordWindow^

Password Entry window.

Demo Password Entry Window, you will want to copy the source for this widget and rewrite it.

class PasswordWindow(FocusedToplevel):
	def __init__(self, window=None, **kwargs):
		...
	def destroy(self) -> None:
		...
	def iconify(self):
		"""Display widget as icon."""
	def iconmask(self, bitmap=None):
		"""Set mask for the icon bitmap of this widget. Return the
        mask if None is given."""

py_simple_ttk.widgets.ToplevelWidgets.ListWindow^

Window to select an option from a Scrolled Listbox

class ListWindow(FocusedToplevel):
	def __init__(self, *args, options: list, text: str = 'Select Item:', on_yes=None, yes_text: str = 'Continue', on_cancel=None, cancel_text: str = 'Cancel', no_destroy: bool = False, select_mode: str = 'single', **kwargs):
		...
	def destroy(self) -> None:
		...
	def iconify(self):
		"""Display widget as icon."""
	def iconmask(self, bitmap=None):
		"""Set mask for the icon bitmap of this widget. Return the
        mask if None is given."""

Misc Widgets^

py_simple_ttk.widgets.ToolTip.ToolTip^

Easy ToolTip

Easily show theme-friendly tooltip. Currently only left and right align are supported.

class ToolTip(ToolTipBase):
	def __init__(self, parent: object, text: str, align: str = 'left'):
		...

py_simple_ttk.widgets.SizegripWidgets.EasySizegrip^

Sizegrip widget with bindings

Automatically packs self and binds mouse presses for systems that don't bind automatically.

class EasySizegrip(Sizegrip):
	def __init__(self, *args, **kwargs):
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def disable(self):
		...
	def enable(self):
		...

SuperLib.utils^

Utils^

py_simple_ttk.utils.utils.check_if_module_installed^

Indicates if a packages is installed. Returns a Boolean

def check_if_module_installed(package: str) -> bool:
> 	...

py_simple_ttk.utils.utils.check_string_contains^

Returns (True, char_index) if any character from the list exists in the string otherwise returns (False, None)

def check_string_contains(string: str, contains_list: tuple) -> tuple:
> 	...

py_simple_ttk.utils.utils.dummy_function^

Dummy function that nicely prints out any passed args and kwargs. Returns True

def dummy_function(*args, **kwargs) -> bool:
> 	...

py_simple_ttk.utils.utils.get_friendly_time^

Gets a time string in one of several modes. Modes: all, time, date, nice_date. Returns a String

def get_friendly_time(timestamp, mode: str = 'all') -> str:
> 	...

py_simple_ttk.utils.utils.get_installed_packages^

Get an alphabetized list of available packages. Returns a List

def get_installed_packages() -> list:
> 	...

py_simple_ttk.utils.utils.get_unix_timestamp^

Get a unix timestamp. Returns a Float

def get_unix_timestamp() -> float:
> 	...

py_simple_ttk.utils.utils.get_unix_timestring^

Get a unix timestring. Returns a String

def get_unix_timestring() -> str:
> 	...

py_simple_ttk.utils.utils.get_user_home_folder^

Cross-platform function to get a user's home folder

def get_user_home_folder() -> str:
> 	...

py_simple_ttk.utils.utils.open_folder_in_explorer^

Cross-platform way to open a folder in the default file manager for a system

def open_folder_in_explorer(path) -> None:
> 	...

py_simple_ttk.utils.utils.sort_dict_by_keys^

Sorts a dictionary by its keys

def sort_dict_by_keys(source: dict, reverse: bool = False) -> collections.OrderedDict:
> 	...

py_simple_ttk.utils.utils.timer_decorator^

Decorator to add timing to a function

def timer_decorator(func: Callable) -> None:
> 	...

File Generators^

py_simple_ttk.utils.HTML_Generator.HTML_Generator^

class HTML_Generator(object):
	def __init__(self, indent='\t'):
		...
	def add_body_line(self, text=''):
		...
	def add_bold(self, text=''):
		...
	def add_center(self, text=''):
		...
	def add_comment(self, text):
		...
	def add_div(self, text=''):
		...
	def add_divider(self):
		...
	def add_list(self, items=[], ordered=False):
		...
	def add_list_item(self, item: str):
		...
	def add_paragraph(self, text=''):
		...
	def assemble(self):
		...
	def end_bold(self):
		...
	def end_center(self):
		...
	def end_div(self):
		...
	def end_list(self, ordered=False):
		...
	def end_paragraph(self):
		...
	def get_indent(self, offset=0):
		...
	def save(self, path):
		...
	def start_bold(self, text=''):
		...
	def start_center(self, text=''):
		...
	def start_div(self, text=''):
		...
	def start_list(self, items=[], ordered=False):
		...
	def start_paragraph(self, text=''):
		...

py_simple_ttk.utils.TXT_Generator.TXT_Generator^

class TXT_Generator(object):
	def __init__(self, ):
		...
	def add_body_line(self, text=''):
		...
	def add_divider(self):
		...
	def assemble(self):
		...
	def save(self, path):
		...

py_simple_ttk.utils.MD_Generator.MD_Generator^

class MD_Generator(object):
	def __init__(self, title=None, footnote_title='Notes:', footnote_heading_level=2, numbered_toc=False):
		...
	def add_blockquote(self, text, end='\n\n'):
		...
	def add_bold(self, text, end='\n\n'):
		...
	def add_bold_italic(self, text, end='\n'):
		...
	def add_break(self):
		...
	def add_code_block(self, text, lang='', end='\n'):
		...
	def add_heading_1(self, text, **kwargs):
		...
	def add_heading_2(self, text, **kwargs):
		...
	def add_heading_3(self, text, **kwargs):
		...
	def add_heading_4(self, text, **kwargs):
		...
	def add_heading_5(self, text, **kwargs):
		...
	def add_heading_6(self, text, **kwargs):
		...
	def add_horizontal_rule(self):
		...
	def add_italic(self, text, end='\n'):
		...
	def add_link(self, link, text=None, tooltip=None):
		...
	def add_multi_blockquote(self, texts):
		...
	def add_ordered_list(self, texts, indent=0):
		...
	def add_paragraph(self, text, end='\n\n'):
		...
	def add_to_ordered_list(self, index, text, indent=0):
		...
	def add_to_unordered_list(self, text, indent=0):
		...
	def add_toc(self, title, end='\n\n'):
		...
	def add_unordered_list(self, texts, indent=0):
		...
	def assemble(self):
		...
	def decrease_toc_depth(self):
		...
	def get_prefix(self):
		...
	def increase_toc_depth(self):
		...
	def insert_footnote(self, text):
		...
	def save(self, path):
		...
	def set_slogan(self, slogan):
		...

History Mixin^

py_simple_ttk.utils.History.HistoryMixin^

Abstract mixin to add history-tracking to an application

This object is meant to be used as a mixin rather than instantiated directly most of the time.

class HistoryMixin(object):
	def __init__(self, data):
		...
	def add_history(self, data):
		...
	def clear_history(self, data):
		...
	def get_history_uid(self):
		...
	def redo(self):
		...
	def undo(self):
		...

Color Functions^

py_simple_ttk.utils.color.reduce_255^

Limits a val to a range of 0 to 255

def reduce_255(in_value: int, maxval: int = 255) -> int:
> 	...

py_simple_ttk.utils.color.rgb_to_hex^

Converts an rgb tuple to hex

def rgb_to_hex(rgb: tuple) -> str:
> 	...

py_simple_ttk.utils.color.rgba_to_hex^

Converts an rgba tuple to rgba hex

def rgba_to_hex(rgba: tuple) -> str:
> 	...

py_simple_ttk.utils.color.hex_to_rgb^

Converts hex to rgb tuple

def hex_to_rgb(hex: str) -> tuple:
> 	...

py_simple_ttk.utils.color.hex_to_rgba^

Tries to convert rgba hex to rgba, on failure converts rgb hex to rgb and sets a full opacity

def hex_to_rgba(hex: str) -> tuple:
> 	...

py_simple_ttk.utils.color.get_gradient^

Generates a black / white gradient with a given number of steps

def get_gradient(steps: int) -> tuple:
> 	...

py_simple_ttk.utils.color.rgb_to_scalar^

Converts an rgb itterable to scalar list

def rgb_to_scalar(rgb: tuple) -> tuple:
> 	...

py_simple_ttk.utils.color.scalar_to_rgb^

Converts rgb scalar to rgb list

def scalar_to_rgb(rgb: tuple) -> tuple:
> 	...

py_simple_ttk.utils.color.linear_gradient^

Generates a linear gradient between two colors, accepts html hex or rgb formats

def linear_gradient(start_hex: str = '#000000', finish_hex: str = '#FFFFFF', n: int = 10) -> list:
> 	...

py_simple_ttk.utils.color.get_rainbow^

Generates a rainbow with a given number of steps. Steps must be divisible by 4)

def get_rainbow(steps: int) -> tuple:
> 	...

MegaWidgets^

Notes MegaWidget^

py_simple_ttk.mega_widgets.notes.NotesTab^

class NotesTab(Tab):
	def __init__(self, notebook, app):
		...
	def copy_note(self, note):
		...
	def delete_note(self, note):
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def export_note_html(self, note):
		...
	def export_note_json(self, note):
		...
	def export_note_markdown(self, note):
		...
	def export_note_text(self, note):
		...
	def load_notes(self):
		...
	def make_new_note(self, title):
		...
	def new_note(self, event=None):
		...
	def on_toplevel_destroy(self, *args):
		"""Function for toplevels to call on no / cancel"""
	def reload_notes(self):
		...
	def rename_note(self, note):
		...
	def start_new_note(self, title=None):
		...

Conversation MegaWidget^

py_simple_ttk.mega_widgets.chat.ConversationsTab^

class ConversationsTab(Tab):
	def __init__(self, notebook, app):
		...
	def copy_conversation(self, conversation):
		...
	def delete_conversation(self, conversation):
		...
	def destroy(self):
		"""Destroy this and all descendants widgets."""
	def export_conversation_html(self, conversation):
		...
	def export_conversation_json(self, conversation):
		...
	def export_conversation_markdown(self, conversation):
		...
	def export_conversation_text(self, conversation):
		...
	def get_cached_icon(self, size, color, char):
		...
	def get_user_icon(self, user):
		...
	def load_conversations(self):
		...
	def make_new_conversation(self, title):
		...
	def new_conversation(self, event=None):
		...
	def on_toplevel_destroy(self, *args):
		"""Function for toplevels to call on no / cancel"""
	def reload_conversations(self):
		...
	def rename_conversation(self, conversation):
		...
	def start_new_conversation(self, title=None):
		...

Profile Management^

py_simple_ttk.utils.ProfilesSystem.ProfilesSystem^

class ProfilesSystem(object):
	def __init__(self, select_profile_actions: list = [], refresh_profiles_actions: list = [], profiles_dir: str = 'C:\\Users\\arcti\\github\\py_simple_ttk\\Profiles', handle_duplicates: bool = True):
		...
	def add_refresh_profiles_action(self, action: Callable) -> None:
		"""Add an action to the profiles list refresh actions"""
	def add_refresh_profiles_actions(self, actions: list) -> None:
		"""Add a list of actions to the profiles list refresh actions"""
	def add_select_profile_action(self, action: Callable) -> None:
		"""Add an action to the profile switch actions"""
	def add_select_profile_actions(self, actions: list) -> None:
		"""Add a list of actions to the profile switch actions"""
	def check_if_name_exists_in_profiles(self, name: str, profiles: list = None) -> bool:
		"""Check if a name exists in a list of profiles, if no list is provided uses the list of all profiles. `Returns a Bool`"""
	def clear_refresh_profile_actions(self, new: list = []) -> None:
		"""Clear out the profiles list refresh actions, optionally replacing them with new ones"""
	def clear_select_profile_actions(self, new: list = []) -> None:
		"""Clear out the profile switch actions, optionally replacing them with new ones"""
	def create_profile(self, name: str) -> py_simple_ttk.utils.ProfilesSystem.UserProfile:
		"""Creates a profile with a given name. `Raises ValueError` if the profile name already exists. `Returns a UserProfile`"""
	def delete_profile(self, profile: py_simple_ttk.utils.ProfilesSystem.UserProfile) -> None:
		...
	def get_last_used_profile(self, profiles: list = None) -> py_simple_ttk.utils.ProfilesSystem.UserProfile:
		"""Returns the most recently accessed profile"""
	def get_profile_by_username(self, name: str) -> py_simple_ttk.utils.ProfilesSystem.UserProfile:
		...
	def get_profile_names(self) -> list:
		"""Returns an alphabetically sorted list of profile names"""
	def handle_duplicate_profile_names(self, name: str) -> None:
		"""Makes profile names unique if they have identical names. The most recently accessed profile (according to the file json) keeps its name untouched. `Returns None`"""
	def handle_refresh_profiles_actions(self) -> None:
		"""Handle on-refresh-profiles actions"""
	def handle_select_profile_actions(self) -> None:
		"""Handle on-profile-selection actions"""
	def select_profile(self, profile: py_simple_ttk.utils.ProfilesSystem.UserProfile) -> None:
		"""Change the currently selected profile"""
	def select_profile_by_username(self, name: str) -> None:
		...
	def sort_profiles_by_accessed(self, profiles: list = None) -> None:
		"""Sort a list of profiles by last accessed, if no list is provided returns a sorted list of all profiles in the system. `Returns a List`"""

py_simple_ttk.utils.ProfilesSystem.UserProfile^

A class to represent a User / User's Preferences

Must pass a unique username and a unique identifier for new profile.

class UserProfile(object):
	def __init__(self, path: str, username: str = None, atomic: str = None):
		...
	def clear_preferences(self, preferences: list = None) -> None:
		...
	def get_preference(self, key: str) -> object:
		...
	def load(self, path: str = None, overwrite_path: bool = False) -> None:
		...
	def save(self, path: str = None, overwrite_path: bool = False) -> None:
		...
	def set_preference(self, key: str, value: str) -> None:
		...
	def set_username(self, name: str) -> None:
		...

py_simple_ttk.utils.ProfilesSystem.get_profiles_folder^

Gets the absolute path to the included profiles folder. Returns a String

def get_profiles_folder() -> str:
> 	...

py_simple_ttk.utils.ProfilesSystem.get_profiles_list^

Gets a list of profile files at a given path. Returns a List of Path strings

def get_profiles_list(path: str = './Profiles', verbose: bool = False) -> list:
> 	...

Changelog^

0.1.30^

Cleanup, bug fixes, add HamburgerFrame

0.1.29^

Move TicTacToe to examples

0.1.28^

Move SuperWidgetMixin from WidgetsCore.py to SuperWidget.py

0.1.27^

Add ActiveButton, ActiveCheckButton, ActiveComboBox, ActiveEntry, ActiveOptionMenu, ActiveProgressbar, ActiveRadioButton, ActiveScale, ColumnFrame, CycleButton, LabeledButton, LabeledMultiButton, LabeledCycleButton, LabeledMultiCycleButton, LabeledMultiRadioTable, LabeledMultiSimpleRadioTable, LabeledRadioTable, LabeledSimpleRadioTable, RadioTable, SimpleRadioTable, Remove: LabeledRadioButton, LabeledMultiRadioButton

0.1.26^

Add Spinbox widgets, fix Copybox

0.1.25^

Reduce packaged fonts color pallete

0.1.24^

Update readme generator with more config keys, fix ini readme md code block being marked as python

0.1.23^

Add columns to Configurable Launcher

0.1.22^

Fix readme

0.1.21^

Fix readme

0.1.20^

Add counter widget.

0.1.19^

Add dynamic launcher system.

0.1.18^

Add Ordered Listbox, add more bindings to SuperWidget, cleanup

0.1.17^

Add set_desktop_background to WidgetsCore.py

0.1.16^

Add needs_white_text to color.py, add pyinstaller compatibility to WidgetsCore.get_asset

0.1.15^

Fix misnamed function in color.py

0.1.14^

Fix missing import in app.py

0.1.13^

reduced variety of packaged font images, fixed bug with constrained widgets command not triggering

0.1.12^

Add Constrained + Labeled + Multi Entries (>35 widgets)

0.1.11^

Fix LabeledPathEntry error when no dialog type was specified

0.1.10^

Add LabeledPathEntry to EntryWidgets.py

0.1.9^

Add pencil icons to assets

0.1.8^

Fix labeled button not running command on press

0.1.7^

add labeled button

0.1.6^

Fix missing Labeler import

0.1.5^

Fix broken package

0.1.4^

Fix broken package

0.1.3^

More cleanup, input fixes.py

0.1.2^

Cleanup, move type lists to generate_readme.py

0.1.1^

Fix missing 'ListWindow' import in app.py

0.1.0^

Modulize

Generated with py_simple_readme