feat: pass clicked column to grid context menu dynamic content provider

vaadin-grid-flow-parent/vaadin-grid-flow-integration-tests/src/main/java/com/vaadin/flow/component/grid/contextmenu/DynamicContextMenuGridPage.java

@@ -27,6 +27,7 @@
 
     public DynamicContextMenuGridPage() {
         gridWithDynamicContextMenu();
+        gridWithDynamicContentProvider();
     }
 
     private void gridWithDynamicContextMenu() {
@@ -53,4 +54,30 @@
         grid.setId("grid-with-dynamic-context-menu");
         add(grid);
     }
+
+    private void gridWithDynamicContentProvider() {
+        final Grid<Person> grid = new Grid<>();
+        Grid.Column<Person> nameColumn = grid.addColumn(Person::getFirstName)
+                .setHeader("Name");
+        grid.addColumn(Person::getAge).setHeader("Age");
+
+        grid.setItems(IntStream.range(0, 50)
+                .mapToObj(i -> new Person("Person " + i, i)).toList());
+
+        GridContextMenu<Person> contextMenu = grid.addContextMenu();
+
+        contextMenu.setDynamicContentProvider(context -> {
+            Person person = context.item();
+            contextMenu.removeAll();
+            if (person != null) {
+                contextMenu.addItem(context.column() == nameColumn
+                        ? "Call " + person.getFirstName()
+                        : "Age " + person.getAge());
+            }
+            return person != null;
+        });
+
+        grid.setId("grid-with-dynamic-content-provider");
+        add(grid);
+    }
 }

vaadin-grid-flow-parent/vaadin-grid-flow-integration-tests/src/test/java/com/vaadin/flow/component/grid/contextmenu/DynamicContextMenuGridIT.java

@@ -36,7 +36,7 @@
     @Before
     public void init() {
         open();
-        grid = $(GridElement.class).first();
+        grid = $(GridElement.class).id("grid-with-dynamic-context-menu");
         verifyClosed();
     }
 
@@ -76,6 +76,25 @@
                 getContextMenu().getDomProperty("innerText"));
     }
 
+    @Test
+    public void dynamicContentProvider_menuContentDependsOnClickedColumn() {
+        GridElement columnGrid = $(GridElement.class)
+                .id("grid-with-dynamic-content-provider");
+
+        columnGrid.getCell(5, 1).contextClick();
+        verifyOpened();
+        Assert.assertEquals("Age 5",
+                getContextMenu().getDomProperty("innerText"));
+
+        $("body").first().click();
+        verifyClosed();
+
+        columnGrid.getCell(5, 0).contextClick();
+        verifyOpened();
+        Assert.assertEquals("Call Person 5",
+                getContextMenu().getDomProperty("innerText"));
+    }
+
     private TestBenchElement getContextMenu() {
         return $("vaadin-context-menu").first();
     }

vaadin-grid-flow-parent/vaadin-grid-flow-integration-tests/test/grid-connector-context-menu.test.ts

@@ -23,6 +23,7 @@ describe('grid connector - context menu', () => {
 
     column = grid.querySelector('vaadin-grid-column')!;
     column.id = 'name-column';
+    column._flowId = 'col0';
 
     setRootItems(grid.$connector, [
       { key: '0', name: 'foo' },
@@ -41,14 +42,14 @@ describe('grid connector - context menu', () => {
   });
 
   it('should return item key and column id in before-open detail', () => {
-    let detail: { key: string, columnId: string };
+    let detail: { key: string; columnId: string; internalColumnId: string };
     // The detail is resolved while the source event is still being dispatched
     grid.addEventListener('contextmenu', (e) => {
       detail = grid.getContextMenuBeforeOpenDetail(new CustomEvent('contextmenu', { detail: { sourceEvent: e } }));
     });
     getBodyCellContent(grid, 0, 1)!.dispatchEvent(new MouseEvent('contextmenu', { bubbles: true, composed: true }));
 
-    expect(detail!).to.deep.equal({ key: '0', columnId: 'name-column' });
+    expect(detail!).to.deep.equal({ key: '0', columnId: 'name-column', internalColumnId: 'col0' });
   });
 
   it('should prevent context menu on selection column left click', () => {

vaadin-grid-flow-parent/vaadin-grid-flow/src/main/java/com/vaadin/flow/component/grid/contextmenu/GridContextMenu.java

@@ -15,6 +15,7 @@
  */
 package com.vaadin.flow.component.grid.contextmenu;
 
+import java.io.Serializable;
 import java.util.List;
 import java.util.Optional;
 
@@ -44,6 +45,7 @@
         implements HasGridMenuItems<T> {
 
     private SerializablePredicate<T> dynamicContentHandler;
+    private SerializablePredicate<DynamicContentContext<T>> dynamicContentProvider;
 
     /**
      * Event that is fired when a {@link GridMenuItem} is clicked inside a
@@ -64,7 +66,7 @@
             grid = (Grid<T>) getSource().getContextMenu().getTarget();
             item = Optional.ofNullable(grid.getDataCommunicator().getKeyMapper()
                     .get(grid.getElement()
                             .getProperty("_contextMenuTargetItemKey")));
         }
 
         /**
@@ -135,6 +137,27 @@
 
     }
 
+    /**
+     * The context of a context-click on a {@link Grid}, passed to the
+     * {@link #setDynamicContentProvider(SerializablePredicate) dynamic content
+     * provider}.
+     *
+     * @param item
+     *            the item in the Grid that was the target of the context-click,
+     *            or {@code null} if the context-click didn't target any item
+     *            (eg. if targeting a header)
+     * @param column
+     *            the column in the Grid that was the target of the
+     *            context-click, or {@code null} if the context-click didn't
+     *            target any application column (eg. selection column)
+     * @param <T>
+     *            the grid bean type
+     * @since 25.4
+     */
+    public record DynamicContentContext<T>(T item,
+            Grid.Column<T> column) implements Serializable {
+    }
+
     /**
      * Creates an empty context menu to be used with a Grid.
      */
@@ -247,9 +270,15 @@
      * </p>
      *
      * @return the callback function that is executed before opening the context
-     *         menu, or {@code null} if not specified.
+     *         menu, or {@code null} if not specified or if a dynamic content
+     *         provider was set with
+     *         {@link #setDynamicContentProvider(SerializablePredicate)}.
      * @since 4.1
+     * @deprecated Use {@link #getDynamicContentProvider()} together with
+     *             {@link #setDynamicContentProvider(SerializablePredicate)},
+     *             which also receives the clicked column.
      */
+    @Deprecated(since = "25.4", forRemoval = true)
     public SerializablePredicate<T> getDynamicContentHandler() {
         return dynamicContentHandler;
     }
@@ -267,26 +296,107 @@
      * The boolean return value of this callback specifies if the context menu
      * will be opened.
      * </p>
+     * <p>
+     * Replaces any provider set with
+     * {@link #setDynamicContentProvider(SerializablePredicate)}.
+     * </p>
      *
      * @param dynamicContentHandler
      *            the callback function that will be executed before opening the
      *            context menu.
      * @since 4.1
+     * @deprecated Use {@link #setDynamicContentProvider(SerializablePredicate)}
+     *             instead, which also receives the clicked column.
      */
+    @Deprecated(since = "25.4", forRemoval = true)
     public void setDynamicContentHandler(
             SerializablePredicate<T> dynamicContentHandler) {
         this.dynamicContentHandler = dynamicContentHandler;
+        this.dynamicContentProvider = null;
+    }
+
+    /**
+     * Gets the callback function that is executed before the context menu is
+     * opened to dynamically provide its contents.
+     *
+     * @return the callback function that is executed before opening the context
+     *         menu, or {@code null} if not specified or if a handler was set
+     *         with {@link #setDynamicContentHandler(SerializablePredicate)}.
+     * @see #setDynamicContentProvider(SerializablePredicate)
+     * @since 25.4
+     */
+    public SerializablePredicate<DynamicContentContext<T>> getDynamicContentProvider() {
+        return dynamicContentProvider;
+    }
+
+    /**
+     * Sets a callback that is executed before the context menu is opened to
+     * dynamically provide its contents.
+     *
+     * <p>
+     * The callback receives a {@link DynamicContentContext} with the clicked
+     * item and column. This is useful when the context menu items depend on
+     * what was clicked, for example:
+     * </p>
+     *
+     * <pre>
+     * contextMenu.setDynamicContentProvider(context -&gt; {
+     *     contextMenu.removeAll();
+     *     Person person = context.item();
+     *     if (context.column() == nameColumn) {
+     *         contextMenu.addItem("Call", e -&gt; call(person));
+     *     } else if (context.column() == addressColumn) {
+     *         contextMenu.addItem("Show on map", e -&gt; showOnMap(person));
+     *     }
+     *     return true;
+     * });
+     * </pre>
+     *
+     * <p>
+     * The boolean return value of this callback specifies if the context menu
+     * will be opened.
+     * </p>
+     * <p>
+     * Replaces any handler set with
+     * {@link #setDynamicContentHandler(SerializablePredicate)}.
+     * </p>
+     *
+     * @param dynamicContentProvider
+     *            the callback function that will be executed before opening the
+     *            context menu, or {@code null} to remove it
+     * @since 25.4
+     */
+    public void setDynamicContentProvider(
+            SerializablePredicate<DynamicContentContext<T>> dynamicContentProvider) {
+        this.dynamicContentProvider = dynamicContentProvider;
+        this.dynamicContentHandler = null;
     }
 
     /**
      * {@inheritDoc}
      * 
      * @since 25.0
      */
+    @SuppressWarnings("removal")
     @Override
     protected boolean onBeforeOpenMenu(ObjectNode eventDetail) {
         Grid<T> grid = (Grid<T>) getTarget();
         String key = eventDetail.get("key").asString();
+        String columnId = eventDetail.get("columnId").asString();
+
+        // The grid connector also reports the target with a separate server
+        // call, which is processed after this event. Update the target here so
+        // that it is up to date in the dynamic content handlers.
+        grid.getElement().setProperty("_contextMenuTargetItemKey", key);
+        grid.getElement().setProperty("_contextMenuTargetColumnId", columnId);
+
+        if (dynamicContentProvider != null) {
+            final T item = grid.getDataCommunicator().getKeyMapper().get(key);
+            final Grid.Column<T> column = getColumnByInternalId(grid,
+                    eventDetail.get("internalColumnId").asString());
+            return dynamicContentProvider
+                    .test(new DynamicContentContext<>(item, column));
+        }
 
         if (getDynamicContentHandler() != null) {
             final T item = grid.getDataCommunicator().getKeyMapper().get(key);
@@ -295,4 +405,12 @@
 
         return super.onBeforeOpenMenu(eventDetail);
     }
+
+    private static <T> Grid.Column<T> getColumnByInternalId(Grid<T> grid,
+            String internalId) {
+        return grid.getColumns().stream()
+                .filter(column -> internalId
+                        .equals(column.getElement().getProperty("_flowId")))
+                .findFirst().orElse(null);
+    }
 }

vaadin-grid-flow-parent/vaadin-grid-flow/src/main/resources/META-INF/frontend/vaadin-grid/gridConnector.ts

@@ -512,7 +512,8 @@ export class GridConnector {
       const eventContext = grid.getEventContext(sourceEvent);
       const key = eventContext.item?.key || '';
       const columnId = eventContext.column?.id || '';
-      return { key, columnId };
+      const internalColumnId = eventContext.column?._flowId ?? '';
+      return { key, columnId, internalColumnId };
     };
 
     grid.preventContextMenu = (event) => {

vaadin-grid-flow-parent/vaadin-grid-flow/src/main/resources/META-INF/frontend/vaadin-grid/vaadin-grid-types.d.ts

@@ -93,7 +93,11 @@ export interface FlowGridInternals {
   _isDetailsOpened(item: Item | undefined): boolean;
   isItemSelectable(item: Item | null | undefined): boolean;
   _mapSorters(): GridSorterDefinition[];
-  getContextMenuBeforeOpenDetail(event: CustomEvent<{ sourceEvent?: Event }>): { key: string; columnId: string };
+  getContextMenuBeforeOpenDetail(event: CustomEvent<{ sourceEvent?: Event }>): {
+    key: string;
+    columnId: string;
+    internalColumnId: string;
+  };
   preventContextMenu(event: MouseEvent): boolean;
 }