tessl/pypi-pytermtk
Python Terminal Toolkit for creating sophisticated text-based user interfaces with Qt-like API and full widget support
—
Pending
input-widgets.mddocs/
Input Widgets
Interactive widgets for user input including buttons, text fields, checkboxes, combo boxes, and other form controls.
Capabilities
Button Widget
TTkButton provides clickable button functionality with text labels and customizable appearance.
class TTkButton(TTkWidget):
def __init__(self, parent=None, text="", **kwargs):
"""
Initialize a button widget.
Parameters:
- text (str): Button text label
- border (bool): Whether to show border (default: True)
- checkable (bool): Whether button can be toggled (default: False)
- checked (bool): Initial checked state for checkable buttons
"""
def setText(self, text):
"""Set the button text."""
def text(self):
"""Get the button text."""
def setCheckable(self, checkable):
"""Set whether the button is checkable/toggleable."""
def isCheckable(self):
"""Check if the button is checkable."""
def setChecked(self, checked):
"""Set the checked state (for checkable buttons)."""
def isChecked(self):
"""Get the checked state."""
def click(self):
"""Programmatically click the button."""
# Signals
clicked: pyTTkSignal # Emitted when button is clicked
pressed: pyTTkSignal # Emitted when button is pressed down
released: pyTTkSignal # Emitted when button is released
toggled: pyTTkSignal # Emitted when checkable button is toggledLine Edit Widget
TTkLineEdit provides single-line text input functionality with validation and formatting options.
class TTkLineEdit(TTkWidget):
def __init__(self, parent=None, text="", **kwargs):
"""
Initialize a line edit widget.
Parameters:
- text (str): Initial text content
- inputType (int): Input type for validation
- readOnly (bool): Whether the field is read-only
- maxLength (int): Maximum text length
- placeholderText (str): Placeholder text when empty
"""
def setText(self, text):
"""Set the text content."""
def text(self):
"""Get the text content."""
def clear(self):
"""Clear the text content."""
def copy(self):
"""Copy selected text to clipboard."""
def cut(self):
"""Cut selected text to clipboard."""
def paste(self):
"""Paste text from clipboard."""
def selectAll(self):
"""Select all text."""
def setReadOnly(self, readOnly):
"""Set read-only state."""
def isReadOnly(self):
"""Check if field is read-only."""
def setMaxLength(self, maxLength):
"""Set maximum text length."""
def maxLength(self):
"""Get maximum text length."""
def setPlaceholderText(self, text):
"""Set placeholder text."""
def placeholderText(self):
"""Get placeholder text."""
def setInputType(self, inputType):
"""Set input validation type."""
def setEchoMode(self, mode):
"""Set echo mode for password fields."""
def hasSelectedText(self):
"""Check if text is selected."""
def selectedText(self):
"""Get selected text."""
def cursorPosition(self):
"""Get cursor position."""
def setCursorPosition(self, position):
"""Set cursor position."""
# Signals
textChanged: pyTTkSignal # Emitted when text changes
textEdited: pyTTkSignal # Emitted when text is edited by user
returnPressed: pyTTkSignal # Emitted when Enter is pressed
editingFinished: pyTTkSignal # Emitted when editing is finishedCheckbox Widget
TTkCheckbox provides a checkable option with text label.
class TTkCheckbox(TTkWidget):
def __init__(self, parent=None, text="", **kwargs):
"""
Initialize a checkbox widget.
Parameters:
- text (str): Checkbox label text
- checked (bool): Initial checked state
"""
def setText(self, text):
"""Set the checkbox label text."""
def text(self):
"""Get the checkbox label text."""
def setChecked(self, checked):
"""Set the checked state."""
def isChecked(self):
"""Get the checked state."""
def toggle(self):
"""Toggle the checked state."""
def setTristate(self, tristate):
"""Enable/disable tristate mode."""
def isTristate(self):
"""Check if tristate mode is enabled."""
def setCheckState(self, state):
"""Set check state (for tristate checkboxes)."""
def checkState(self):
"""Get check state."""
# Signals
toggled: pyTTkSignal # Emitted when checked state changes
clicked: pyTTkSignal # Emitted when checkbox is clicked
stateChanged: pyTTkSignal # Emitted when check state changesRadio Button Widget
TTkRadioButton provides mutually exclusive selection within a group.
class TTkRadioButton(TTkWidget):
def __init__(self, parent=None, **kwargs):
"""
Initialize a radio button widget.
Parameters:
- radiogroup (str): Radio group name for mutual exclusion (default: 'DefaultGroup')
- checked (bool): Initial checked state (default: False)
- checkStatus (TTkK.CheckState): Initial check state
- text (TTkString): Radio button label text
"""
def setText(self, text):
"""Set the radio button label text."""
def text(self):
"""Get the radio button label text."""
def setChecked(self, checked):
"""Set the checked state."""
def isChecked(self):
"""Get the checked state."""
def setCheckState(self, state):
"""Set check state (for tristate support)."""
def checkState(self):
"""Get check state."""
def radioGroup(self):
"""Get the radio group name."""
def toggle(self):
"""Toggle the checked state."""
# Signals
toggled: pyTTkSignal # Emitted when checked state changes
clicked: pyTTkSignal # Emitted when radio button is clickedCombo Box Widget
TTkComboBox provides a dropdown selection widget with customizable options.
class TTkComboBox(TTkWidget):
def __init__(self, parent=None, **kwargs):
"""
Initialize a combo box widget.
Parameters:
- list (list): Initial list of items
- index (int): Initial selected index (default: -1)
- insertPolicy (TTkK.InsertPolicy): Policy for inserting items (default: TTkK.InsertAtBottom)
- textAlign (TTkK.Alignment): Text alignment (default: TTkK.CENTER_ALIGN)
- editable (bool): Whether the combo box is editable (default: False)
"""
def addItem(self, text, userData=None):
"""Add an item to the combo box."""
def addItems(self, texts):
"""Add multiple items to the combo box."""
def insertItem(self, index, text, userData=None):
"""Insert an item at a specific index."""
def removeItem(self, index):
"""Remove an item at a specific index."""
def clear(self):
"""Clear all items."""
def count(self):
"""Get the number of items."""
def currentIndex(self):
"""Get the current selected index."""
def setCurrentIndex(self, index):
"""Set the current selected index."""
def currentText(self):
"""Get the current selected text."""
def setCurrentText(self, text):
"""Set the current text (for editable combo boxes)."""
def itemText(self, index):
"""Get text of item at index."""
def itemData(self, index):
"""Get user data of item at index."""
def setItemText(self, index, text):
"""Set text of item at index."""
def setItemData(self, index, userData):
"""Set user data of item at index."""
def findText(self, text):
"""Find index of text in items."""
def setEditable(self, editable):
"""Set whether combo box is editable."""
def isEditable(self):
"""Check if combo box is editable."""
def lineEdit(self):
"""Get the line edit widget for editable combo boxes."""
# Signals
currentIndexChanged: pyTTkSignal # Emitted when selection changes
currentTextChanged: pyTTkSignal # Emitted when current text changes
editTextChanged: pyTTkSignal # Emitted when edit text changes (editable mode)Spin Box Widget
TTkSpinBox provides numeric input with increment/decrement controls.
class TTkSpinBox(TTkWidget):
def __init__(self, parent=None, **kwargs):
"""
Initialize a spin box widget.
Parameters:
- value (int): Initial value
- minimum (int): Minimum allowed value
- maximum (int): Maximum allowed value
- step (int): Step size for increment/decrement
"""
def setValue(self, value):
"""Set the current value."""
def value(self):
"""Get the current value."""
def setMinimum(self, minimum):
"""Set the minimum allowed value."""
def minimum(self):
"""Get the minimum allowed value."""
def setMaximum(self, maximum):
"""Set the maximum allowed value."""
def maximum(self):
"""Get the maximum allowed value."""
def setRange(self, minimum, maximum):
"""Set the value range."""
def setSingleStep(self, step):
"""Set the step size."""
def singleStep(self):
"""Get the step size."""
def stepUp(self):
"""Increment the value by one step."""
def stepDown(self):
"""Decrement the value by one step."""
def setPrefix(self, prefix):
"""Set text prefix."""
def prefix(self):
"""Get text prefix."""
def setSuffix(self, suffix):
"""Set text suffix."""
def suffix(self):
"""Get text suffix."""
# Signals
valueChanged: pyTTkSignal # Emitted when value changes
textChanged: pyTTkSignal # Emitted when displayed text changesSlider Widget
TTkSlider provides a sliding control for selecting values within a range.
class TTkSlider(TTkWidget):
def __init__(self, parent=None, **kwargs):
"""
Initialize a slider widget.
Parameters:
- orientation (int): Horizontal or vertical orientation
- value (int): Initial value
- minimum (int): Minimum value
- maximum (int): Maximum value
"""
def setValue(self, value):
"""Set the current value."""
def value(self):
"""Get the current value."""
def setMinimum(self, minimum):
"""Set the minimum value."""
def minimum(self):
"""Get the minimum value."""
def setMaximum(self, maximum):
"""Set the maximum value."""
def maximum(self):
"""Get the maximum value."""
def setRange(self, minimum, maximum):
"""Set the value range."""
def setOrientation(self, orientation):
"""Set slider orientation."""
def orientation(self):
"""Get slider orientation."""
def setTickPosition(self, position):
"""Set tick mark position."""
def setTickInterval(self, interval):
"""Set tick mark interval."""
def setSingleStep(self, step):
"""Set single step size."""
def setPageStep(self, step):
"""Set page step size."""
# Signals
valueChanged: pyTTkSignal # Emitted when value changes
sliderPressed: pyTTkSignal # Emitted when slider is pressed
sliderReleased: pyTTkSignal # Emitted when slider is released
sliderMoved: pyTTkSignal # Emitted when slider is moved
rangeChanged: pyTTkSignal # Emitted when range changesList Widget
TTkListWidget provides a scrollable list of selectable items with search functionality.
class TTkListWidget(TTkAbstractScrollWidget):
def __init__(self, parent=None, **kwargs):
"""
Initialize a list widget.
Parameters:
- items (list[str]): Initial list of items (default: [])
- selectionMode (TTkK.SelectionMode): Selection mode (default: SingleSelection)
- dragDropMode (TTkK.DragDropMode): Drag/drop behavior (default: NoDragDrop)
- showSearch (bool): Show search field (default: True)
"""
def addItem(self, text):
"""Add a single item to the list."""
def addItems(self, items):
"""Add multiple items to the list."""
def insertItem(self, index, text):
"""Insert an item at a specific index."""
def removeItem(self, index):
"""Remove an item at a specific index."""
def clear(self):
"""Clear all items from the list."""
def count(self):
"""Get the number of items."""
def currentItem(self):
"""Get the current selected item."""
def currentRow(self):
"""Get the current selected row index."""
def setCurrentRow(self, row):
"""Set the current selected row."""
def selectedItems(self):
"""Get list of selected items."""
def item(self, row):
"""Get item at specific row."""
def itemText(self, row):
"""Get text of item at specific row."""
def setSelectionMode(self, mode):
"""Set the selection mode."""
def selectionMode(self):
"""Get the selection mode."""
def setDragDropMode(self, mode):
"""Set drag and drop mode."""
def dragDropMode(self):
"""Get drag and drop mode."""
# Signals
itemClicked: pyTTkSignal # Emitted when item is clicked
textClicked: pyTTkSignal # Emitted when item text is clicked
searchModified: pyTTkSignal # Emitted when search text changes
currentItemChanged: pyTTkSignal # Emitted when current item changesUsage Examples
Button with Click Handler
import TermTk as ttk
root = ttk.TTk()
container = ttk.TTkContainer(parent=root)
# Create button
button = ttk.TTkButton(parent=container, text="Click Me!", pos=(5, 5), size=(15, 3))
# Connect click handler
@ttk.pyTTkSlot()
def on_button_click():
print("Button was clicked!")
button.setText("Clicked!")
button.clicked.connect(on_button_click)
root.mainloop()Form with Various Input Widgets
import TermTk as ttk
root = ttk.TTk()
container = ttk.TTkContainer(parent=root)
layout = ttk.TTkVBoxLayout()
# Name input
name_layout = ttk.TTkHBoxLayout()
name_label = ttk.TTkLabel(text="Name:")
name_edit = ttk.TTkLineEdit(placeholderText="Enter your name")
name_layout.addWidget(name_label)
name_layout.addWidget(name_edit, stretch=1)
# Age input
age_layout = ttk.TTkHBoxLayout()
age_label = ttk.TTkLabel(text="Age:")
age_spin = ttk.TTkSpinBox(minimum=0, maximum=120, value=25)
age_layout.addWidget(age_label)
age_layout.addWidget(age_spin)
age_layout.addStretch(1)
# Options
newsletter_cb = ttk.TTkCheckbox(text="Subscribe to newsletter")
gender_layout = ttk.TTkHBoxLayout()
male_rb = ttk.TTkRadioButton(text="Male")
female_rb = ttk.TTkRadioButton(text="Female")
gender_layout.addWidget(male_rb)
gender_layout.addWidget(female_rb)
gender_layout.addStretch(1)
# Country selection
country_layout = ttk.TTkHBoxLayout()
country_label = ttk.TTkLabel(text="Country:")
country_combo = ttk.TTkComboBox()
country_combo.addItems(["USA", "Canada", "UK", "Australia"])
country_layout.addWidget(country_label)
country_layout.addWidget(country_combo, stretch=1)
# Submit button
submit_btn = ttk.TTkButton(text="Submit")
# Add all to main layout
layout.addLayout(name_layout)
layout.addLayout(age_layout)
layout.addWidget(newsletter_cb)
layout.addLayout(gender_layout)
layout.addLayout(country_layout)
layout.addStretch(1)
layout.addWidget(submit_btn)
container.setLayout(layout)
# Form submission handler
@ttk.pyTTkSlot()
def submit_form():
print(f"Name: {name_edit.text()}")
print(f"Age: {age_spin.value()}")
print(f"Newsletter: {newsletter_cb.isChecked()}")
print(f"Country: {country_combo.currentText()}")
submit_btn.clicked.connect(submit_form)
root.mainloop()Slider Control Example
import TermTk as ttk
root = ttk.TTk()
container = ttk.TTkContainer(parent=root)
layout = ttk.TTkVBoxLayout()
# Volume control
volume_label = ttk.TTkLabel(text="Volume: 50")
volume_slider = ttk.TTkSlider(orientation=ttk.TTkConstant.Horizontal,
minimum=0, maximum=100, value=50)
# Update label when slider moves
@ttk.pyTTkSlot(int)
def update_volume(value):
volume_label.setText(f"Volume: {value}")
volume_slider.valueChanged.connect(update_volume)
layout.addWidget(volume_label)
layout.addWidget(volume_slider)
container.setLayout(layout)
root.mainloop()List Widget Selection Example
import TermTk as ttk
root = ttk.TTk()
container = ttk.TTkContainer(parent=root)
layout = ttk.TTkVBoxLayout()
# Create list widget
list_widget = ttk.TTkListWidget()
list_widget.addItems([
"Python", "JavaScript", "Java", "C++", "C#",
"Go", "Rust", "Swift", "Kotlin", "TypeScript"
])
# Status label
status_label = ttk.TTkLabel(text="Select a programming language")
# Handle selection changes
@ttk.pyTTkSlot()
def on_selection_changed():
current = list_widget.currentItem()
if current:
status_label.setText(f"Selected: {current}")
else:
status_label.setText("No selection")
list_widget.currentItemChanged.connect(on_selection_changed)
# Handle item clicks
@ttk.pyTTkSlot()
def on_item_clicked():
current = list_widget.currentItem()
print(f"Clicked: {current}")
list_widget.itemClicked.connect(on_item_clicked)
layout.addWidget(list_widget)
layout.addWidget(status_label)
container.setLayout(layout)
root.mainloop()Install with Tessl CLI
npx tessl i tessl/pypi-pytermtk