TraitsUI

https://docs.enthought.com/traitsui/
Admin
TraitsUI is a Python toolkit for building user interfaces with a comprehensive collection of...
Tokens:407,901
Snippets:3,058
Trust Score:10
Update:6 months ago
Show doc for...
Tokens:
Raw
### Start Qt Event Loop for Interactive GUIs

Source: https://docs.enthought.com/traitsui/_sources/tutorials/traits_ui_scientific_app.rst.txt

This example demonstrates how to create a TraitsUI panel for an object and then explicitly start the Qt event loop to make the GUI interactive. This is typically handled automatically by configure_traits().

```python
from traits.api import HasTraits, Int
from traitsui.api import View, Item

from pyface.qt.QtGui import QApplication

class Counter(HasTraits):
    value = Int(0)

    view = View(
        Item('value'),
        title='Counter',
        buttons=['OK', 'Cancel'],
    )


if __name__ == '__main__':
    counter = Counter()
    panel = counter.edit_traits()

    app = QApplication.instance() 
    if app is None:
        app = QApplication([])
    
    app.exec_()

```

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

### TreeEditor Example

Source: https://docs.enthought.com/traitsui/traitsui_user_manual/factories_advanced_extra.html

This example demonstrates the setup for a TreeEditor, including defining data models (Employee, Department, Company, Owner) and the necessary traitsui imports. It shows how to instantiate nested objects and prepare them for display in a tree structure.

```python
# tree_editor.py -- Example of a tree editor

from traits.api import HasTraits, Instance, List, Str, Regex
from traitsui.api import (
    Action,
    Group,
    Handler,
    HGroup,
    Item,
    Menu,
    Separator,
    TreeEditor,
    TreeNode,
    View,
    VSplit,
)
from traitsui.editors.tree_editor import (
    NewAction,
    CopyAction,
    CutAction,
    PasteAction,
    DeleteAction,
    RenameAction,
)


class Employee(HasTraits):
    name = Str('<unknown>')
    title = Str()
    phone = Regex(regex=r'\d\d\d-\d\d\d\d')

    def default_title(self):
        self.title = 'Senior Engineer'


class Department(HasTraits):
    name = Str('<unknown>')
    employees = List(Employee)


class Company(HasTraits):
    name = Str('<unknown>')
    departments = List(Department)
    employees = List(Employee)


class Owner(HasTraits):
    name = Str('<unknown>')
    company = Instance(Company)


owner = Owner(
    name='wile',
    company=Company(
        name='Acme Labs, Inc.',
        departments=[
            Department(name='Marketing', employees=[mike, betty]),
            Department(name='Engineering', employees=[dave, susan, jason]),
        ],
        employees=[dave, susan, mike, betty, jason],
    ),
)

# View for objects that aren't edited
no_view = View()

# Actions used by tree editor context menu
def_title_action = Action(name='Default title', action='object.default')

dept_action = Action(
    name='Department',
    action='handler.employee_department(editor,object)',
)

```

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

### Example: Code Editor with Key Binding Editor

Source: https://docs.enthought.com/traitsui/traitsui_user_manual/factories_advanced_extra.html

This example demonstrates creating a user interface with a code editor and an associated key binding editor, invoked by a button.

```python
# Example 17: Code editor with key binding editor

```

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

### Start Qt Event Loop for traitsUI Dialog

Source: https://docs.enthought.com/traitsui/tutorials/traits_ui_scientific_app.html

Use this snippet to display a traitsUI dialog and start the Qt event loop. Ensure QApplication is imported and instantiated before calling exec_().

```python
from pyface.qt.QtGui import QApplication

from traits.api import HasTraits, Int


class Counter(HasTraits):
    value = Int()


Counter().edit_traits()
QApplication.instance().exec_()
```

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

### Example Test Code Snippet

Source: https://docs.enthought.com/traitsui/_sources/traitsui_user_manual/testing/howtos/add_new_location.rst.txt

An example of how the test code would look after setting up custom location support. It shows finding a container and then locating a specific button within it.

```python
container = UITester().find_by_id(ui, "some_container")
button_wrapper = container.locate(LabelledButton("OK"))
```

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

### Python Threading Example

Source: https://docs.enthought.com/traitsui/tutorials/traits_ui_scientific_app.html

Shows how to create and run a separate thread in Python using the `threading` module. This is a fundamental example for understanding concurrency.

```python
# thread_example.py

from threading import Thread
from time import sleep


class MyThread(Thread):
    def run(self):
        sleep(2)
        print("MyThread done")


my_thread = MyThread()

my_thread.start()
print("Main thread done")
```

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

### Complete Test Example

Source: https://docs.enthought.com/traitsui/traitsui_user_manual/testing/tutorials/first_test.html

A full test implementation combining GUI creation, interaction, and assertion.

```python
from traitsui.testing.api import DisplayedText, KeySequence, UITester

form = Form()
tester = UITester()
with tester.create_ui(form) as ui:
    first_name_field = tester.find_by_name(ui, "first_name")
    first_name_field.perform(KeySequence("Leia"))

    last_name_field = tester.find_by_name(ui, "last_name")
    last_name_field.perform(KeySequence("Skywalker"))

    full_name_field = tester.find_by_name(ui, "full_name")
    displayed = full_name_field.inspect(DisplayedText())
    assert displayed == "Leia Skywalker"
```

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

### Configure Acquisition Thread

Source: https://docs.enthought.com/traitsui/_sources/tutorials/traits_ui_scientific_app.rst.txt

Initializes and starts an acquisition thread by assigning camera and UI components.

```python
self.acquisition_thread.acquire = self.camera.acquire
self.acquisition_thread.experiment = self.experiment
self.acquisition_thread.image_show = self.image_show
self.acquisition_thread.results = self.results
self.acquisition_thread.start()
```

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

### Import statements for traitsui.ui

Source: https://docs.enthought.com/traitsui/_modules/traitsui/ui.html

Initial imports and module setup for the traitsui.ui module.

```python
# (C) Copyright 2004-2023 Enthought, Inc., Austin, TX
# All rights reserved.
#
# This software is provided without warranty under the terms of the BSD
# license included in LICENSE.txt and may be redistributed only under
# the conditions described in the aforementioned license. The license
# is also available online at http://www.enthought.com/licenses/BSD.txt
#
# Thanks for using Enthought open source!

""" Defines the UI class used to represent an active traits-based user
    interface.
"""

import shelve
import os
from warnings import warn

from pyface.ui_traits import Image
from traits.api import (
    Any,
    Bool,
    Callable,
    Dict,
    Event,
    HasPrivateTraits,
    Instance,
    Int,
    List,
    Property,
    Str,
    TraitError,
    observe,
)

from traits.trait_base import traits_home, is_str

from .editor import Editor

from .view_elements import ViewElements

from .handler import Handler, ViewHandler

from .toolkit import toolkit

from .ui_info import UIInfo

from .item import Item

from .group import Group, ShadowGroup
```

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

### Launch Application

Source: https://docs.enthought.com/traitsui/_sources/tutorials/traits_ui_scientific_app.rst.txt

Entry point to instantiate and display the main window.

```python
if __name__ == '__main__':
    MainWindow().configure_traits()
```

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

### ListColumn Get Value

Source: https://docs.enthought.com/traitsui/_modules/traitsui/table_column.html

Gets the string representation of the value at the specified index for a ListColumn.

```python
def get_value(self, object):
        """Gets the value of the column for a specified object."""
        return str(object[self.index])
```

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

### Implement init Method

Source: https://docs.enthought.com/traitsui/_modules/traitsui/delegating_handler.html

Initializes the UI and sets up trait notification delegation for sub-handlers.

```python
def init(self, info):
    """Initializes the controls of a user interface.

    This method is called after all user interface elements have been
    created, but before the user interface is displayed. Use this method to
    further customize the user interface before it is displayed.

    This method is overridden here to delegate to sub-handlers.

    Parameters
    ----------
    info : *UIInfo* object
        The UIInfo object associated with the view

    Returns
    -------
    initialized : bool
        A boolean, indicating whether the user interface was successfully
        initialized. A True value indicates that the UI can be displayed;
        a False value indicates that the display operation should be
        cancelled.
    """

    # Iterate through our sub-handlers, and for each method whose name is
    # of the form 'object_name_changed', where 'object' is the name of an
    # object in the UI's context, create a trait notification handler that
    # will call the method whenever object's 'name' trait changes.
    logger.debug("Initializing delegation in DelegatingHandler [%s]", self)
    context = info.ui.context
    for h in self.sub_handlers:
        # fixme: I don't know why this wasn't here before... I'm not
        # sure this is right!
        h.init(info)

        for name in self._each_trait_method(h):
            if name[-8:] == "_changed":
                prefix = name[:-8]
                col = prefix.find("_", 1)
                if col >= 0:
                    object = context.get(prefix[:col])
                    if object is not None:
                        logger.debug(
                            "\tto method [%s] on handler[%s]", name, h
                        )
                        method = getattr(h, name)
                        trait_name = prefix[col + 1 :]
                        self._dispatchers.append(
                            Dispatcher(method, info, object, trait_name)
                        )

                        # Also invoke the method immediately so initial
                        # user interface state can be correctly set.
                        if object.base_trait(trait_name).type != "event":
                            method(info)

            # fixme: These are explicit workarounds for problems with:-
            #
            # 'GeometryHierarchyViewHandler'
            #
            # which is used in the :-
            #
            # 'GeometryHierarchyTreeEditor'
            #
            # which are in the 'encode.cad.ui.geometry' package.
            #
            # The tree editor has dynamic views, and hence the handler gets
            # wrapped by a 'DelegatingHandler'. Unfortunately the handler
            # has a couple of methods that aren't picked up by the usual
            # wrapping strategy:-
            #
            # 1) 'tree_item_selected'
            #
            # - which is obviously called when a tree item is selected.
            #
            # 2) 'inspect_object'
            #
            # - which is called directly as as action from the context menu
            #   defined in the tree editor.
            #
            elif name in ["tree_item_selected", "inspect_object"]:
                self.__dict__[name] = self._create_delegate(h, name)

    return True
```

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

### Get UI Preferences

Source: https://docs.enthought.com/traitsui/_modules/traitsui/ui.html

Gets the preferences to be saved for the user interface, including editor-specific preferences and key bindings.

```python
def get_prefs(self, prefs=None):
    """Gets the preferences to be saved for the user interface."""
    ui_prefs = {}
    if prefs is not None:
        ui_prefs[""] = prefs

    if self.key_bindings is not None:
        ui_prefs["$"] = self.key_bindings

    info = self.info
    for name in self._names:
        editor = getattr(info, name, None)
        if isinstance(editor, Editor) and (editor.ui is self):
            prefs = editor.save_prefs()
            if prefs is not None:
                ui_prefs[name] = prefs

    return ui_prefs
```

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

### Get Raw Value

Source: https://docs.enthought.com/traitsui/_modules/traitsui/table_column.html

Gets the unformatted value of the column for a specified object. Handles potential errors during retrieval.

```python
def get_raw_value(self, object):
        """Gets the unformatted value of the column for a specified object."""
        try:
```

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

### Select GUI toolkit

Source: https://docs.enthought.com/traitsui/_modules/traitsui/toolkit.html

Initializes and returns the current GUI toolkit. If no toolkit is specified, it attempts to find one via entry points.

```python
def toolkit(*toolkits):
    """Selects and returns a low-level GUI toolkit.

    Use this function to get a reference to the current toolkit.

    Parameters
    ----------
    *toolkits : strings
        Toolkit names to try if toolkit not already selected.  If not supplied,
        will try all ``traitsui.toolkits`` entry points until a match is found.

    Returns
    -------
    toolkit
        Appropriate concrete Toolkit subclass for selected toolkit.

    Raises
    ------
    TraitError
        If no working toolkit is found.
    RuntimeError
        If no ETSConfig.toolkit is set but the toolkit cannot be loaded for
        some reason.
    """
    global _toolkit

    if _toolkit is None:
        if len(toolkits) > 0:
            _toolkit = find_toolkit("traitsui.toolkits", toolkits)
        else:
            _toolkit = find_toolkit("traitsui.toolkits")
    return _toolkit
```

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

### Get Column Type

Source: https://docs.enthought.com/traitsui/_modules/traitsui/table_column.html

Gets the data type of the column for a specified object. This method is part of the TableColumn class.

```python
def get_type(self, object):
    """Gets the type of data for the column for a specified object."""
    return self.type
```

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

### Get Column Label

Source: https://docs.enthought.com/traitsui/_modules/traitsui/table_column.html

Gets the label of the column, falling back to a user-friendly name derived from the trait name if not explicitly set.

```python
def _get_label(self):
        """Gets the label of the column."""
        if self._label is not None:
            return self._label
        return user_name_for(self.name)
```

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

### Displaying a View as a Wizard

Source: https://docs.enthought.com/traitsui/traitsui_user_manual/custom_view.html

Example demonstrating how to display a TraitsUI View in a 'wizard' style. This is only supported for the wx backend. Wizards are always modal and live, and ignore the 'buttons' attribute.

```python
# wizard.py -- Example of a traits-based wizard UI

from traits.api import HasTraits, Str
from traits.etsconfig.api import ETSConfig
from traitsui.api import Item, View, VGroup


class Person(HasTraits):
    first_name = Str()
    last_name = Str()

    company = Str()
    position = Str()

    view = View(
        VGroup(Item("first_name"), Item("last_name")),
        VGroup(Item("company"), Item("position")),
    )


person = Person(
    first_name='Postman',
    last_name='Pat',
    company="Enthought",
    position="Software Developer",
)


if ETSConfig.toolkit == "wx":
    # Wizard window is currently only available for wx backend.
    person.configure_traits(kind='wizard')

```

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

### Initialize Main View

Source: https://docs.enthought.com/traitsui/traitsui_user_manual/factories_advanced_extra.html

Constructs the main application view containing the tree editor.

```python
view = View(
    Group(
        Item(name='company', id='company', editor=tree_editor, resizable=True),
        orientation='vertical',
        show_labels=True,
        show_left=True,
    ),
    title='Company Structure',
    id='traitsui.tests.tree_editor_test',
    dock='horizontal',
    drop_class=HasTraits,
    handler=TreeHandler(),
    buttons=['Undo', 'OK', 'Cancel'],
    resizable=True,
    width=0.3,
    height=0.3,
)

if __name__ == '__main__':
    owner.configure_traits(view=view)
```

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

### Get Traits Node Children in TraitsUI

Source: https://docs.enthought.com/traitsui/_modules/traitsui/value_tree.html

Retrieves the children for a traits node. It gets all trait and attribute names, sorts them, and creates nodes for each, handling potential getattr exceptions.

```python
    def tno_get_children(self, node):
        """Gets the object's children."""
        names = sorted(self._get_names())
        value = self.value
        node_for = self.node_for
        nodes = []
        for name in names:
            try:
                item_value = getattr(value, name, "<unknown>")
            except Exception as excp:
                item_value = "<%s>" % excp
            nodes.append(node_for("." + name, item_value))

        return nodes
```

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

### Handler.init

Source: https://docs.enthought.com/traitsui/api/traitsui.handler.html

Initializes the controls of a user interface before it is displayed.

```APIDOC
## init(info)

### Description
Initializes the controls of a user interface. This method is called after all user interface elements have been created, but before the user interface is displayed.

### Parameters
- **info** (UIInfo object) - Required - The UIInfo object associated with the view.

### Response
- **initialized** (bool) - A Boolean indicating whether the user interface was successfully initialized.
```

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

### Create UI instance

Source: https://docs.enthought.com/traitsui/_modules/traitsui/ui.html

Creates a user interface from the associated View template object.

```python
def ui(self, parent, kind):
    """Creates a user interface from the associated View template object."""
    if (parent is None) and (kind in kind_must_have_parent):
        kind = "live"
    self.view.on_trait_change(
```

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

### Instance Editor with Instance Selection

Source: https://docs.enthought.com/traitsui/_sources/traitsui_user_manual/factories_basic.rst.txt

Demonstrates how to use InstanceEditor to allow users to select and edit instances from a list, such as choosing a team captain.

```python
instance_editor_selection.py
```

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

### Get Trait Handler by Name

Source: https://docs.enthought.com/traitsui/_modules/traitsui/tabular_adapter.html

Retrieves a handler function for a given trait name. Returns a lambda for getting or setting the trait's value. Use this to dynamically create trait accessors.

```python
    def _get_handler_for(self, name, prefix):
        """Returns the handler for a specified trait name (or None if not
        found).
        """
        if self.trait(name) is not None:
            if prefix == "get_":
                return lambda: getattr(self, name)

            return lambda: setattr(self, name, self.value)

        return None
```

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

### Displaying a View in Wizard Style

Source: https://docs.enthought.com/traitsui/_sources/traitsui_user_manual/custom_view.rst.txt

Use the 'wizard' kind for sequential, modal, and live user interactions. This style is primarily for controlled processes like software installation and is only supported by the WX backend.

```python
from traits.api import HasTraits, Str
from traitsui.api import View, Item, Group, Wizard

class MyWizard(HasTraits):

    name = Str('World')

    view = View(
        Group(
            Item('name'),
            label='Page 1'
        ),
        title='My Wizard'
    )

    def wizard_application(self):
        # This is a simplified example; actual wizard logic would be more complex.
        # The wizard view itself handles the navigation between pages.
        return MyWizard().edit_traits(kind='wizard')

if __name__ == '__main__':
    MyWizard().wizard_application()

```

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

### Get Help Text for Item

Source: https://docs.enthought.com/traitsui/_modules/traitsui/item.html

Retrieves the help text for an Item in a given UI context. Returns None for spacers. For trait Items, it attempts to get help from the object's trait.

```python
def get_help(self, ui):
    """Gets the help text associated with the Item in a specified UI."""
    # Return 'None' if the Item is a separator or spacer:
    if self.is_spacer():
        return None

    # Otherwise, it must be a trait Item:
    if self.help != "":
        return self.help

    object = eval(self.object_, globals(), ui.context)

    return object.base_trait(self.name).get_help()
```

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

### GET /find_by_id

Source: https://docs.enthought.com/traitsui/_modules/traitsui/testing/tester/ui_tester.html

Locates a TraitsUI editor by its identifier.

```APIDOC
## GET /find_by_id

### Description
Finds the TraitsUI editor with the given identifier and returns a new UIWrapper object for further interactions.

### Parameters
#### Query Parameters
- **ui** (traitsui.ui.UI) - Required - The UI created, e.g. by create_ui.
- **id** (str) - Required - Id for finding an item in the UI, typically defined on Item.id or Group.id.

### Response
- **wrapper** (UIWrapper) - A wrapper object for further interactions with the editor.
```

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

### Configure Toolbar Actions

Source: https://docs.enthought.com/traitsui/traitsui_user_manual/handler.html

Define an Action with tooltip and image, then add it to a View's toolbar.

```python
From pyface.api import ImageResource

recalc = Action(
    name="Recalculate",
    action="do_recalc",
    toolip="Recalculate the results",
    image=ImageResource("recalc.png"),
)
```

```python
View(
   # view contents,
   # ...,
   toolbar=ToolBar(my_action),
)
```

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

### POST /ui/create

Source: https://docs.enthought.com/traitsui/_modules/traitsui/ui.html

Creates a user interface from the associated View template object.

```APIDOC
## POST /ui/create

### Description
Creates a user interface from the associated View template object. If the parent is None and the kind is restricted (e.g., 'panel', 'subpanel'), the kind is defaulted to 'live'.

### Method
POST

### Endpoint
/ui/create

### Parameters
#### Request Body
- **parent** (Instance) - Required - The parent UI object or None.
- **kind** (Str) - Required - The type of UI to create (e.g., 'panel', 'subpanel', 'live').

### Response
#### Success Response (200)
- **result** (Bool) - Indicates the result of the UI creation process.
```

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

### Get Specific View Element Types with trait_views()

Source: https://docs.enthought.com/traitsui/_sources/traitsui_user_manual/tips.rst.txt

Use trait_views() with a view element type (e.g., View, Group, Item) to get a list of all named instances of that type defined in the object's class. Note that only named elements are returned.

```python
sam.trait_views(View)
```

```python
sam.trait_views(Group)
```

```python
sam.trait_views(Item)
```

```python
sam.trait_views(ViewSubElement)
```

```python
sam.trait_views(ViewElement)
```

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

### view_application

Source: https://docs.enthought.com/traitsui/_modules/traitsui/toolkit.html

Creates a GUI-toolkit-specific modal dialog user interface that runs as a complete application.

```APIDOC
## view_application

### Description
Creates a GUI-toolkit-specific modal dialog user interface that runs as a complete application using information from the specified View object.

### Parameters
#### Path Parameters
- **context** (object or dictionary) - Required - A single object or a dictionary of string/object pairs, whose trait attributes are to be edited.
- **view** (view or string) - Required - A View object that defines a user interface for editing trait attribute values.
- **kind** (string) - Optional - The type of user interface window to create.
- **handler** (Handler object) - Optional - A handler object used for event handling in the dialog box.
- **id** (string) - Optional - A unique ID for persisting preferences about this user interface.
- **scrollable** (Boolean) - Optional - Indicates whether the dialog box should be scrollable.
```

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

### GET /traitsui/editor_factory/custom_editor

Source: https://docs.enthought.com/traitsui/genindex.html

Retrieves a custom editor instance from an EditorFactory.

```APIDOC
## GET /traitsui/editor_factory/custom_editor

### Description
Retrieves a custom editor instance associated with an EditorFactory.

### Method
GET

### Endpoint
/traitsui/editor_factory/custom_editor
```

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

### GET /traitsui/group/get_id

Source: https://docs.enthought.com/traitsui/api/traitsui.group.html

Retrieves the unique identifier for a group instance.

```APIDOC
## GET /traitsui/group/get_id

### Description
Returns an ID for the group.

### Method
GET
```

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

### Use Pre-defined Button Lists

Source: https://docs.enthought.com/traitsui/_sources/traitsui_user_manual/custom_view.rst.txt

Example showing how to import and assign a pre-defined button list to the buttons attribute.

```python
from traitsui.menu import OKCancelButtons

    ...
    buttons=OKCancelButtons,
)
```

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

### GET /find_by_name

Source: https://docs.enthought.com/traitsui/_modules/traitsui/testing/tester/ui_tester.html

Locates a TraitsUI editor by its name attribute.

```APIDOC
## GET /find_by_name

### Description
Finds the TraitsUI editor with the given name and returns a new UIWrapper object.

### Parameters
#### Query Parameters
- **ui** (traitsui.ui.UI) - Required - The UI created, e.g. by create_ui.
- **name** (str) - Required - A single name for retrieving a target on a UI.

### Response
- **wrapper** (UIWrapper) - A wrapper object for further interactions with the editor.
```

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

### Instance Editor Demo

Source: https://docs.enthought.com/traitsui/_sources/traitsui_user_manual/factories_basic.rst.txt

Illustrates different styles for editing instances: simple button, custom editor panel, and text representation.

```python
InstanceEditor()
```

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

### Function: dock_window_theme

Source: https://docs.enthought.com/traitsui/_modules/traitsui/dock_window_theme.html

Get or set the default DockWindow theme.

```APIDOC
## Function dock_window_theme

### Description
Get or set the default DockWindow theme.

### Parameters
- **theme** (ATheme, optional) - The new theme to set as default. If None, the current default theme is returned.

### Returns
(ATheme) - The previous default DockWindow theme.
```

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

### Define MainWindow Class

Source: https://docs.enthought.com/traitsui/tutorials/traits_ui_scientific_app.html

The main application window, containing the TextDisplay and Camera components. It sets up the default camera instance.

```python
from traits.api import Instance
from traitsui.api import View

class MainWindow(HasTraits):
    display = Instance(TextDisplay, ())

    camera = Instance(Camera)

    def _camera_default(self):
        return Camera(display=self.display)

    view = View('display', 'camera', style="custom", resizable=True)
```

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

### Object Name Retrieval

Source: https://docs.enthought.com/traitsui/_modules/traitsui/tree_node.html

Method for getting the display name of an object.

```APIDOC
## GET /api/objects/{id}/name

### Description
Returns the name to use for an object instance, typically displayed in menus or lists.

### Method
GET

### Endpoint
/api/objects/{id}/name

### Parameters
#### Path Parameters
- **id** (string) - Required - The unique identifier of the object.

### Response
#### Success Response (200)
- **name** (string) - The display name of the object.

#### Response Example
```json
{
  "name": "Object Name"
}
```
```

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

### Get Context Menu

Source: https://docs.enthought.com/traitsui/_modules/traitsui/table_column.html

Retrieves the context menu for a column when right-clicked.

```python
def get_menu(self, object, row):
        """Returns the context menu to display when the user right-clicks on
        the column for a specified object row.
        """
        return self.menu
```

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

### Demonstrate sequential execution

Source: https://docs.enthought.com/traitsui/_sources/tutorials/traits_ui_scientific_app.rst.txt

Illustrates standard sequential program flow where each function must complete before the next begins.

```python
do_a()
do_b()
do_c()
```

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

### example_ui_wrapper

Source: https://docs.enthought.com/traitsui/api/traitsui.testing.tester.tests.test_ui_wrapper.html

Function to retrieve an instance of UIWrapper for testing purposes.

```APIDOC
## example_ui_wrapper

### Description
Returns an instance of UIWrapper for testing purposes.

### Parameters
#### Request Body
- **kwargs** (dict) - Optional - Values to use instead of the default values.

### Response
#### Success Response (200)
- **wrapper** (UIWrapper) - An instance of UIWrapper.
```

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

### Get Vertical Alignment

Source: https://docs.enthought.com/traitsui/_modules/traitsui/table_column.html

Returns the vertical alignment setting for the column.

```python
def get_vertical_alignment(self, object):
        """Returns the vertical alignment for the column for a specified
        object row.
        """
        return self.vertical_alignment
```

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

### Get Horizontal Alignment

Source: https://docs.enthought.com/traitsui/_modules/traitsui/table_column.html

Returns the horizontal alignment setting for the column.

```python
def get_horizontal_alignment(self, object):
        """Returns the horizontal alignment for the column for a specified
        object row.
        """
        return self.horizontal_alignment
```

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

### Prepare UI for TraitsUI

Source: https://docs.enthought.com/traitsui/_modules/traitsui/ui.html

Initializes the TraitsUI by invoking defined methods, hooking events, and synchronizing traits. Handles initialization logic and potential errors during UI creation.

```python
def prepare_ui(self):
        """Performs all processing that occurs after the user interface is
        created.
        """
        # Invoke all of the editor 'name_defined' methods we've accumulated:
        info = self.info.trait_set(initialized=False)
        for method in self._defined:
            method(info)

        # Then reset the list, since we don't need it anymore:
        del self._defined[:]

        # Synchronize all context traits with associated editor traits:
        self.sync_view()

        # Hook all keyboard events:
        toolkit().hook_events(self, self.control, "keys", self.key_handler)

        # Hook all events if the handler is an extended 'ViewHandler':
        handler = self.handler
        if isinstance(handler, ViewHandler):
            toolkit().hook_events(self, self.control)

        # Invoke the handler's 'init' method, and abort if it indicates
        # failure:
        started = handler.init(info)
        if started is False:
            raise TraitError("User interface creation aborted")
        elif not isinstance(started, bool):
            raise ValueError(
                "Handler.init() must return True or False, but instead "
                f"returned {started}.
            )

        # For each Handler method whose name is of the form
        # 'object_name_changed', where 'object' is the name of an object in the
        # UI's 'context', create a trait notification handler that will call
        # the method whenever 'object's 'name' trait changes. Also invoke the
        # method immediately so initial user interface state can be correctly
        # set:
        context = self.context
        for name in self._each_trait_method(handler):
            if name[-8:] == "_changed":
                prefix = name[:-8]
                col = prefix.find("_", 1)
                if col >= 0:
                    object = context.get(prefix[:col])
                    if object is not None:
                        method = getattr(handler, name)
                        trait_name = prefix[col + 1 :]
                        self._dispatchers.append(
                            Dispatcher(method, info, object, trait_name)
                        )
                        if object.base_trait(trait_name).type != "event":
                            method(info)

        # If there are any Editor object's whose 'visible', 'enabled' or
        # 'checked' state is controlled by a 'visible_when', 'enabled_when' or
        # 'checked_when' expression, set up an 'anytrait' changed notification
        # handler on each object in the 'context' that will cause the
        # 'visible', 'enabled' or 'checked' state of each affected Editor to be
        #  set. Also trigger the evaluation immediately, so the visible,
        # enabled or checked state of each Editor can be correctly initialized:
        if (len(self._visible) + len(self._enabled) + len(self._checked)) > 0:
            for object in context.values():
                object.on_trait_change(self._evaluate_when, dispatch="ui")
            self._do_evaluate_when(at_init=True)

        # Indicate that the user interface has been initialized:
        info.initialized = True

```

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

### traitsui.help.default_show_help

Source: https://docs.enthought.com/traitsui/api/traitsui.help.html

The default handler implementation for displaying help associated with a view.

```APIDOC
## traitsui.help.default_show_help

### Description
Default handler for showing the help associated with a view.

### Parameters
- **info** (UIInfo) - Required - The UIInfo object for the current view.
- **control** (object) - Required - The UI control that invokes the help function.
```

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

### Get Length of ReversedList

Source: https://docs.enthought.com/traitsui/_modules/traitsui/editors/table_editor.html

Returns the total number of items in the list.

```python
def __len__(self):
        """Returns the length of the list."""
        return len(self.list)
```

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

### Get Item (Internal)

Source: https://docs.enthought.com/traitsui/_modules/traitsui/list_str_adapter.html

Internal method to retrieve the current item.

```python
def _get_item(self):
        return self.item
```

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

### Demonstrate ArrayEditor usage

Source: https://docs.enthought.com/traitsui/traitsui_user_manual/factories_basic.html

Shows how to define traits using ArrayEditor with specific dimensions and styles.

```python
"""Demo of the ArrayEditor"""

import numpy as np

from traits.api import Array, HasPrivateTraits
from traitsui.api import ArrayEditor, Item, View
from traitsui.menu import NoButtons


class ArrayEditorTest(HasPrivateTraits):

    three = Array(np.int64, (3, 3))

    four = Array(
        np.float64,
        (4, 4),
        editor=ArrayEditor(width=-50),
    )

    view = View(
        Item('three', label='3x3 Integer'),
        '_',
        Item('three', label='Integer Read-only', style='readonly'),
        '_',
        Item('four', label='4x4 Float'),
        '_',
        Item('four', label='Float Read-only', style='readonly'),
        buttons=NoButtons,
        resizable=True,
    )


demo = ArrayEditorTest()

if __name__ == '__main__':
    demo.configure_traits()
```

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

### UIWrapper.help

Source: https://docs.enthought.com/traitsui/_modules/traitsui/testing/tester/ui_wrapper.html

Prints help messages regarding supported interactions and locations for the wrapped target.

```APIDOC
## UIWrapper.help

### Description
Prints documentation for all supported interactions and locations for the current UI target. This method is intended for interactive use.
```

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

### Get Dropped Status

Source: https://docs.enthought.com/traitsui/_modules/traitsui/list_str_adapter.html

Internal method to retrieve the 'dropped' status.

```python
def _get_dropped(self):
        return self.dropped
```

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

### Get Can Edit Status

Source: https://docs.enthought.com/traitsui/_modules/traitsui/list_str_adapter.html

Internal method to retrieve the 'can_edit' status.

```python
def _get_can_edit(self):
        return self.can_edit
```

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

### Handle Help Action

Source: https://docs.enthought.com/traitsui/_modules/traitsui/base_panel.html

Displays help information for the UI by calling the handler's show_help method with the UI's info object.

```python
def _on_help(self, event=None):
    """Handles the user clicking the Help button."""
    self.ui.handler.show_help(self.ui.info)
```

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

### GET /group/find

Source: https://docs.enthought.com/traitsui/_modules/pyface/action/group.html

Finds an item within the group by its unique identifier.

```APIDOC
## GET /group/find

### Description
Finds the item with the specified id within the group.

### Method
GET

### Parameters
#### Query Parameters
- **id** (str) - Required - The id of the item to find.

### Response
#### Success Response (200)
- **item** (ActionManagerItem) - The item with the specified Id, or None if no such item exists.
```

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

### Final Test Structure

Source: https://docs.enthought.com/traitsui/_sources/traitsui_user_manual/testing/tutorials/first_test.rst.txt

The complete setup for the final test implementation.

```python
from traitsui.testing.api import DisplayedText, KeySequence, UITester

form = Form()
tester = UITester()
with tester.create_ui(form) as ui:
```

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

### UITester.__init__

Source: https://docs.enthought.com/traitsui/_modules/traitsui/testing/tester/ui_tester.html

Initializes a new UITester instance to manage GUI testing interactions.

```APIDOC
## __init__

### Description
Initializes the UITester with optional registries, delay settings, and event processing configuration.

### Parameters
#### Request Body
- **registries** (list of TargetRegistry) - Optional - Registries of interaction for different targets.
- **delay** (int) - Optional - Time delay in ms for actions. Defaults to 0.
- **auto_process_events** (bool) - Optional - Whether to process GUI events automatically. Defaults to True.
```

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

### Node Label Management

Source: https://docs.enthought.com/traitsui/api/traitsui.tree_node.html

Functions for getting and setting the display label of a node.

```APIDOC
## tno_set_label(_node_, _label_)

### Description
Sets the label for a specified object.

### Method
PUT (assumed)

### Endpoint
/websites/enthought_traitsui/tno_set_label

### Parameters
#### Path Parameters
- **_node_** (object) - Required - The node to set the label for.
- **_label_** (string) - Required - The new label for the node.
```

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

### Initialize UITester with a custom registry

Source: https://docs.enthought.com/traitsui/traitsui_user_manual/testing/howtos/add_new_location.html

Shows how to initialize UITester with a custom registry that includes newly registered location types and solvers.

```python
tester = UITester(registries=[custom_registry])
```

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

### traitsui.help_template.help_template

Source: https://docs.enthought.com/traitsui/api/traitsui.help_template.html

Function to get or set the current HelpTemplate instance used by the application.

```APIDOC
## GET/SET traitsui.help_template.help_template

### Description
Gets or sets the current HelpTemplate instance in use for formatting Traits UI help pages.

### Parameters
#### Arguments
- **_template** (HelpTemplate) - Optional - The HelpTemplate instance to set as the current template. If omitted, the function returns the current template.
```

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

### Inspect Component Capabilities

Source: https://docs.enthought.com/traitsui/traitsui_user_manual/testing/tutorials/test_with_nested_object.html

Uses the help method to list supported interactions and locations for a component.

```python
n_hours_combobox.help()
```

```python
second_item.help()
```

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

### toolkit

Source: https://docs.enthought.com/traitsui/api/traitsui.toolkit.html

Selects and returns a low-level GUI toolkit reference.

```APIDOC
## toolkit(*toolkits)

### Description
Selects and returns a low-level GUI toolkit. Use this function to get a reference to the current toolkit.

### Parameters
#### Request Body
- **toolkits** (strings) - Optional - Toolkit names to try if toolkit not already selected. If not supplied, will try all traitsui.toolkits entry points.

### Response
- **toolkit** (Toolkit subclass) - Appropriate concrete Toolkit subclass for selected toolkit.

### Errors
- **TraitError**: If no working toolkit is found.
- **RuntimeError**: If no ETSConfig.toolkit is set but the toolkit cannot be loaded.
```

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

### Get search stack level

Source: https://docs.enthought.com/traitsui/_modules/traitsui/ui.html

Returns the current depth of the search stack.

```python
    def push_level(self):
        """Returns the current search stack level."""
        return len(self._search)
```

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

### View Initialization and Content Setting

Source: https://docs.enthought.com/traitsui/_modules/traitsui/view.html

Details on how to initialize a View object and set its content, including handling different types of child elements.

```APIDOC
## View Initialization and Content Setting

This section covers the constructor for the `View` class and its method for setting content.

### `__init__`

```python
def __init__(self, *values, **traits)
```

#### Description
Initializes the `View` object.

#### Parameters
- **`*values`**: Positional arguments representing the content elements of the view.
- **`**traits`**: Keyword arguments for setting view traits.

### `set_content`

```python
def set_content(self, *values)
```

#### Description
Sets the content of a view by processing the provided values and organizing them into appropriate view elements (e.g., `Item`, `Group`, `Include`). If `Item` objects are present, the content is wrapped in a `Group`.

#### Parameters
- **`*values`**: The content elements to set for the view. These can be `ViewSubElement` instances, sequences of elements, strings representing included elements, or other data types that will be wrapped in `Item` objects.
```

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

### Get Can Redo Property

Source: https://docs.enthought.com/traitsui/_modules/traitsui/undo.html

Returns the current state of whether an action can be redone.

```python
def _get_can_redo(self):
        return self._can_redo
```

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

### Configure UI with context

Source: https://docs.enthought.com/traitsui/_sources/traitsui_user_manual/advanced_view.rst.txt

Shows how to replace configure_traits() with a UI call that accepts a context dictionary for multi-object views.

```python
comp_view.ui(context={'h1': house1, 'h2': house2})
```
Tokens:
Raw