feat: add addOpenedChangeListener to ConfirmDialog (#7930)

HerbertsVaadin · sissbruecker · web-flow · commit a5024f2d9584 · 2025-09-02T19:51:21.000+02:00
* feat: add addOpenedChangeListener for ConfirmDialog

* cleanup

* simplify logic to use synced property and property change listener

* cleanup tests

---------

Co-authored-by: Sascha Ißbrücker &lt;sissbruecker@vaadin.com&gt;
diff --git a/vaadin-confirm-dialog-flow-parent/vaadin-confirm-dialog-flow/src/main/java/com/vaadin/flow/component/confirmdialog/ConfirmDialog.java b/vaadin-confirm-dialog-flow-parent/vaadin-confirm-dialog-flow/src/main/java/com/vaadin/flow/component/confirmdialog/ConfirmDialog.java
@@ -25,6 +25,7 @@
 import com.vaadin.flow.component.HasComponents;
 import com.vaadin.flow.component.HasSize;
 import com.vaadin.flow.component.HasStyle;
+import com.vaadin.flow.component.Synchronize;
 import com.vaadin.flow.component.Tag;
 import com.vaadin.flow.component.UI;
 import com.vaadin.flow.component.dependency.JsModule;
@@ -121,6 +122,28 @@ public ClosedEvent(ConfirmDialog source, boolean fromClient) {
         }
     }
 
+    /**
+     * Event that is fired when the confirm dialog's opened state changes.
+     * <p>
+     * Note that this event fires immediately when the opened property changes,
+     * which, when closing the confirm dialog, is before the closing animation
+     * has finished. To wait for the animation to finish, listen for the
+     * {@link ClosedEvent} event.
+     */
+    public static class OpenedChangeEvent
+            extends ComponentEvent<ConfirmDialog> {
+        private final boolean opened;
+
+        public OpenedChangeEvent(ConfirmDialog source, boolean fromClient) {
+            super(source, fromClient);
+            this.opened = source.isOpened();
+        }
+
+        public boolean isOpened() {
+            return opened;
+        }
+    }
+
     @Override
     public String getWidth() {
         return getElement().getProperty("width");
@@ -217,13 +240,12 @@ public ConfirmDialog() {
         // Initialize auto-add behavior
         new OverlayAutoAddController<>(this, () -> true);
 
-        // Listen specifically for the client dialog closing to close it on the
-        // server as well. Not using synchronization for the `opened` property
-        // as that would cause the auto add controller to remove the dialog from
-        // the UI before other event listeners (confirm, reject, cancel) are
-        // fired.
-        getElement().addEventListener("opened-changed", event -> close())
-                .setFilter("event.detail.value === false");
+        setOpened(false);
+
+        getElement().addPropertyChangeListener("opened", event -> {
+            setModality(isOpened());
+            fireEvent(new OpenedChangeEvent(this, event.isUserOriginated()));
+        });
     }
 
     /**
@@ -585,6 +607,23 @@ public Registration addClosedListener(
         return ComponentUtil.addListener(this, ClosedEvent.class, listener);
     }
 
+    /**
+     * Add a listener for when the confirm dialog's opened state changes.
+     * <p>
+     * Note that this event fires immediately when the opened property changes,
+     * which, when closing the confirm dialog, is before the closing animation
+     * has finished. To wait for the animation to finish, use
+     * {@link #addClosedListener(ComponentEventListener)}.
+     *
+     * @param listener
+     *            the listener to add
+     * @return a Registration for removing the event listener
+     */
+    public Registration addOpenedChangeListener(
+            ComponentEventListener<OpenedChangeEvent> listener) {
+        return addListener(OpenedChangeEvent.class, listener);
+    }
+
     /**
      * Sets confirmation dialog header text
      */
@@ -628,6 +667,7 @@ public void close() {
         setOpened(false);
     }
 
+    @Synchronize(property = "opened", value = "opened-changed")
     public boolean isOpened() {
         return getElement().getProperty("opened", false);
     }
@@ -649,7 +689,6 @@ public boolean isOpened() {
      *            close it
      */
     public void setOpened(boolean opened) {
-        setModality(opened);
         getElement().setProperty("opened", opened);
     }
 
diff --git a/vaadin-confirm-dialog-flow-parent/vaadin-confirm-dialog-flow/src/test/java/com/vaadin/flow/component/confirmdialog/ConfirmDialogOpenedChangeListenerTest.java b/vaadin-confirm-dialog-flow-parent/vaadin-confirm-dialog-flow/src/test/java/com/vaadin/flow/component/confirmdialog/ConfirmDialogOpenedChangeListenerTest.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright 2000-2025 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.flow.component.confirmdialog;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import com.vaadin.flow.component.ComponentEventListener;
+import com.vaadin.flow.component.UI;
+import com.vaadin.flow.internal.nodefeature.ElementPropertyMap;
+import com.vaadin.flow.internal.nodefeature.PropertyChangeDeniedException;
+import com.vaadin.flow.server.VaadinSession;
+
+public class ConfirmDialogOpenedChangeListenerTest {
+    private final UI ui = new UI();
+    private ConfirmDialog dialog;
+    private ComponentEventListener<ConfirmDialog.OpenedChangeEvent> mockListener;
+
+    @SuppressWarnings("unchecked")
+    @Before
+    public void setup() {
+        UI.setCurrent(ui);
+
+        VaadinSession session = Mockito.mock(VaadinSession.class);
+        Mockito.when(session.hasLock()).thenReturn(true);
+        ui.getInternals().setSession(session);
+
+        dialog = new ConfirmDialog();
+
+        mockListener = Mockito.mock(ComponentEventListener.class);
+        dialog.addOpenedChangeListener(mockListener);
+    }
+
+    @After
+    public void tearDown() {
+        UI.setCurrent(null);
+    }
+
+    @Test
+    public void open() {
+        dialog.open();
+        assertEventFired(true, false);
+
+        resetMock();
+        syncOpenedFromClient(true);
+        assertNoEventFired();
+    }
+
+    @Test
+    public void close() {
+        dialog.open();
+        resetMock();
+
+        dialog.close();
+        assertEventFired(false, false);
+
+        resetMock();
+        syncOpenedFromClient(false);
+        assertNoEventFired();
+    }
+
+    @Test
+    public void closeFromClient() {
+        dialog.open();
+        resetMock();
+
+        syncOpenedFromClient(false);
+        assertEventFired(false, true);
+
+        resetMock();
+        dialog.close();
+        assertNoEventFired();
+    }
+
+    @Test
+    public void noInitialEvent() {
+        syncOpenedFromClient(false);
+        assertNoEventFired();
+    }
+
+    private void syncOpenedFromClient(boolean opened) {
+        try {
+            dialog.getElement().getNode().getFeature(ElementPropertyMap.class)
+                    .deferredUpdateFromClient("opened", opened).run();
+        } catch (PropertyChangeDeniedException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private void assertNoEventFired() {
+        Mockito.verify(mockListener, Mockito.never())
+                .onComponentEvent(Mockito.any());
+    }
+
+    private void assertEventFired(boolean opened, boolean fromClient) {
+        Mockito.verify(mockListener, Mockito.times(1)).onComponentEvent(
+                Mockito.argThat(event -> event.isOpened() == opened
+                        && event.isFromClient() == fromClient));
+    }
+
+    @SuppressWarnings("unchecked")
+    private void resetMock() {
+        Mockito.reset(mockListener);
+    }
+}
