feat: ui.table context menu items

[mattrunyon]

Fixes #321

Use my branch of web-client-ui to test. The necessary changes are in an external package for the plugin, so don't need to do anything special w/ the plugins. deephaven/web-client-ui#2083

Here's an example with a context menu item on the row and a sub-menu action item on the header

from deephaven import empty_table, time_table, ui

@ui.component
def my_comp():
    t = time_table("PT1S").update(["X=i", "Y=i"])

    return ui.table(
        t,
        context_items=[{ "title": "Test", "action": lambda d: print(d)}],
        context_column_header_items=[
            {
                "title": "Header",
                "actions": [{ "title": "Header-sub", "action": lambda d: print(d)}]
            }
        ]
    )

c = my_comp()

[mattrunyon]

I'm wondering if we should even have context_row_header_items in the spec. We don't currently have row headers in iris-grid, and if we did they would probably be row numbers. Those row numbers are meaningless to the server unless we have keyed rows and use the key as the row header

It's something that wouldn't be hard to add to UITable if we added support/reason for it in iris-grid. But right now there is no reason for it

[dsmmcken]

I feel strongly that the word "context menu" must appear in the name.

context_actions or context_items are not things. It's not just a "context", it's a "context menu". There's no such thing as context having meaning without the word menu beside it. It's a compound noun.

It's like ice cream. You wouldn't label something as ice cone. That's not a thing, it's an ice cream cone. It's a compound noun.

[mattrunyon]

context_menu_items and column_header_context_menu_items? context_menu_column_header_items to me sounds like the context menu has some column_header that I can put items in

Another option would be just context_menu_items and then a dict w/ keys cell and column_header and values for the items, but I think that's probably less Pythonic

[dsmmcken]

what about just context_menu and context_header_menu?

[mattrunyon]

Might be able to add async menu items to this PR if the callables returning callables PR merges first. Feels like that one is close

[mofojed]

Used a whole bunch of menus for testing:

from deephaven import empty_table, ui
import time

t = empty_table(100).update(["x=i", "y=Math.sin(x)"])


def action_context_menu(e):
    return [
        {
            "title": f"Action for {e['value']}",
            "action": lambda d: print(d),
        }
    ]


def delayed_context_menu(e):
    time.sleep(2)
    return [
        {
            "title": f"Delayed action for {e['value']}",
            "action": lambda d: print(d),
        }
    ]


def sub_menus(e):
    return [
        {
            "title": f"Submenu for {e['value']}",
            "actions": [action_context_menu, delayed_context_menu],
        }
    ]


def delayed_sub_menus(e):
    time.sleep(2)
    return [
        {
            "title": f"Delayed submenu for {e['value']}",
            "actions": [action_context_menu, delayed_context_menu],
        }
    ]


def even_menu_only(e):
    if e["value"] % 2 == 0:
        return [
            {
                "icon": 'vsWarning',
                "title": f"Even menu for {e['value']}",
                "action": lambda d: print(d),
                "order": 1,
            }
        ]


action_t = ui.table(t, context_menu=[action_context_menu])

delayed_t = ui.table(
    t,
    context_menu=[delayed_context_menu],
)

all_t = ui.table(
    t,
    context_menu=[
        even_menu_only,
        action_context_menu,
        delayed_context_menu,
        sub_menus,
        delayed_sub_menus,
    ],
)

Looks like it works well so far. Great work!

[mofojed]

So in web-client-ui, we accept an array or just a single item: https://github.com/deephaven/web-client-ui/blob/e13c9d78decdfba2ff76657a024b2df44f2ae0fc/packages/components/src/context-actions/ContextActionUtils.ts#L5

Would be nice if we could handle that. Right now doing this is throwing an error on the JS side on right-click and isn't reported to the user, we should at least handle that better:

from deephaven import empty_table, ui

t = ui.table(
    empty_table(100).update(["x=i", "y=Math.sin(x)"]),
    context_menu=lambda e: {
        "title": f"Action for {e['value']}",
        "action": lambda d: print(d),
    },
)

Currently you need to wrap both the function and the return value from the function in arrays, and you don't need to do either in the ContextAction in web-client-ui:

from deephaven import empty_table, ui

action_t = ui.table(
    empty_table(100).update(["x=i", "y=Math.sin(x)"]),
    context_menu=[
        lambda e: [
            {
                "title": f"Action for {e['value']}",
                "action": lambda d: print(d),
            }
        ]
    ],
)

[mattrunyon]

Ya I was mostly trying to make the types a bit simpler for Python. I can make it support both though

[mofojed]

We should also allow order to be passed in here... right now it's implicitly sorting based on the title, which isn't the best.

[mattrunyon]

Why do you say it is sorting by title? It should just be sorted by the order the actions are defined in Python.

We should allow order, but I figured that could be a followup. I don't really like just saying "well our current menu items are 500, 800, 1000" or whatever they are

Also I think you could pass an order right now since the item gets spread before setting the action/actions