[vcs] IJPL-173924 Replace interactions with changes panel in ChangesViewManager with higher level abstraction

Replace direct usage of CommitChangesViewWithToolbarPanel in ChangesViewManager with BackendChangesView.
Also introduce BackendCommitChangesViewModel, which will have 2 implementations - one using actual component and one relying on RPC.

GitOrigin-RevId: 65e3ff2f014110468f38e3a925b56b383071f312

platform/vcs-impl/api-dump.txt

@@ -812,9 +812,6 @@ f:com.intellij.openapi.vcs.changes.ChangesViewManager$ChangesViewToolWindowPanel
 - dispose():V
 - getActions(Z):java.util.List
 - isAllowExcludeFromCommit():Z
-- scheduleRefresh():V
-- selectChanges(java.util.List):V
-- selectFile(com.intellij.openapi.vfs.VirtualFile):V
 - uiDataSnapshot(com.intellij.openapi.actionSystem.DataSink):V
 - updateCommitWorkflow():V
 com.intellij.openapi.vcs.changes.ChangesViewManager$ChangesViewToolWindowPanel$Listener

platform/vcs-impl/src/com/intellij/openapi/vcs/changes/BackendCommitChangesViewModel.kt

@@ -0,0 +1,156 @@
+// Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+package com.intellij.openapi.vcs.changes
+
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.actionSystem.ActionManager
+import com.intellij.openapi.actionSystem.AnAction
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.Disposer
+import com.intellij.openapi.vcs.FilePath
+import com.intellij.openapi.vcs.changes.CommitChangesViewWithToolbarPanel.ModelProvider.ExtendedTreeModel
+import com.intellij.openapi.vcs.changes.ui.ChangesGroupingPolicyFactory
+import com.intellij.openapi.vcs.changes.ui.ChangesListView
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.platform.vcs.impl.shared.changes.ChangesViewSettings
+import com.intellij.util.ui.tree.TreeUtil
+import com.intellij.vcs.commit.ChangesViewCommitWorkflowHandler
+import org.jetbrains.annotations.ApiStatus
+import javax.swing.JComponent
+import javax.swing.tree.TreePath
+
+internal class BackendChangesView private constructor(
+  val changesPanel: JComponent,
+  val viewModel: BackendCommitChangesViewModel,
+): Disposable {
+  init {
+    Disposer.register(this, viewModel)
+  }
+
+  override fun dispose() {
+  }
+
+  companion object {
+    @JvmStatic
+    fun create(project: Project, parentDisposable: Disposable): BackendChangesView {
+      val tree: ChangesListView = LocalChangesListView(project)
+      val panel = CommitChangesViewWithToolbarPanel(tree, parentDisposable)
+      return BackendChangesView(panel, BackendLocalCommitChangesViewModel(panel))
+    }
+  }
+}
+
+// TODO make RD-friendly implementation, cleanup methods returning tree/component
+internal interface BackendCommitChangesViewModel: Disposable {
+  fun initPanel()
+
+  fun setCommitWorkflowHandler(handler: ChangesViewCommitWorkflowHandler?)
+
+  fun isToolbarHorizontal(): Boolean
+  fun getToolbarComponent(): JComponent
+  fun setToolbarHorizontal(horizontal: Boolean)
+  fun getActions(): List<AnAction>
+  fun isModelUpdateInProgress(): Boolean
+
+  fun setBusy(busy: Boolean)
+  fun scheduleRefreshNow(callback: Runnable?)
+  fun scheduleDelayedRefresh()
+  fun setGrouping(groupingKey: String)
+  fun resetViewImmediatelyAndRefreshLater()
+
+  fun selectFile(vFile: VirtualFile?)
+  fun selectChanges(changes: List<Change>)
+
+  @ApiStatus.Obsolete
+  fun getTree(): ChangesListView
+  @ApiStatus.Obsolete
+  fun getPreferredFocusableComponent(): JComponent
+}
+
+private class BackendLocalCommitChangesViewModel(private val panel: CommitChangesViewWithToolbarPanel): BackendCommitChangesViewModel {
+  private var commitWorkflowHandler: ChangesViewCommitWorkflowHandler? = null
+
+  init {
+    Disposer.register(this, panel)
+  }
+
+  override fun initPanel() {
+    panel.initPanel(ModelProvider())
+  }
+
+  override fun setCommitWorkflowHandler(handler: ChangesViewCommitWorkflowHandler?) {
+    commitWorkflowHandler = handler
+  }
+
+  override fun isToolbarHorizontal(): Boolean = panel.isToolbarHorizontal
+
+  override fun getToolbarComponent(): JComponent = panel.toolbar.component
+
+  override fun setToolbarHorizontal(horizontal: Boolean) {
+    panel.isToolbarHorizontal = horizontal
+  }
+
+  override fun getActions(): List<AnAction> = panel.toolbarActionGroup.getChildren(ActionManager.getInstance()).toList()
+
+  override fun isModelUpdateInProgress(): Boolean = panel.changesView.isModelUpdateInProgress
+
+  override fun setBusy(busy: Boolean) {
+    panel.setBusy(busy)
+  }
+
+  override fun scheduleRefreshNow(callback: Runnable?) {
+    panel.scheduleRefreshNow(callback)
+  }
+
+  override fun scheduleDelayedRefresh() {
+    panel.scheduleRefresh()
+  }
+
+  override fun setGrouping(groupingKey: String) {
+    panel.setGrouping(groupingKey)
+  }
+
+  override fun resetViewImmediatelyAndRefreshLater() {
+    panel.resetViewImmediatelyAndRefreshLater()
+  }
+
+  override fun selectFile(vFile: VirtualFile?) {
+    panel.changesView.selectFile(vFile)
+  }
+
+  override fun selectChanges(changes: List<Change>) {
+    val paths: MutableList<TreePath> = ArrayList()
+    for (change in changes) {
+      panel.changesView.findNodePathInTree(change)?.let { paths.add(it) }
+    }
+    TreeUtil.selectPaths(panel.changesView, paths)
+  }
+
+  override fun getTree(): ChangesListView = panel.changesView
+
+  override fun getPreferredFocusableComponent(): JComponent = panel.changesView.preferredFocusedComponent
+
+  override fun dispose() {
+  }
+
+  private inner class ModelProvider : CommitChangesViewWithToolbarPanel.ModelProvider {
+    override fun getModel(grouping: ChangesGroupingPolicyFactory): ExtendedTreeModel {
+      val project = panel.project
+      val changeListManager = ChangeListManagerImpl.getInstanceImpl(project)
+      val changeLists = changeListManager.changeLists
+      val unversionedFiles = changeListManager.unversionedFilesPaths
+
+      val treeModel = ChangesViewUtil.createTreeModel(
+        project,
+        grouping,
+        changeLists,
+        unversionedFiles,
+        ChangesViewSettings.getInstance(project).showIgnored
+      ) { commitWorkflowHandler?.isActive == true }
+      return ExtendedTreeModel(changeLists, unversionedFiles, treeModel)
+    }
+
+    override fun synchronizeInclusion(changeLists: List<LocalChangeList>, unversionedFiles: List<FilePath>) {
+      commitWorkflowHandler?.synchronizeInclusion(changeLists, unversionedFiles)
+    }
+  }
+}

platform/vcs-impl/src/com/intellij/openapi/vcs/changes/ChangesViewManager.java

@@ -23,7 +23,10 @@ import com.intellij.openapi.util.NlsContexts;
 import com.intellij.openapi.util.registry.Registry;
 import com.intellij.openapi.util.registry.RegistryValue;
 import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.openapi.vcs.*;
+import com.intellij.openapi.vcs.ProjectLevelVcsManager;
+import com.intellij.openapi.vcs.VcsApplicationSettings;
+import com.intellij.openapi.vcs.VcsBundle;
+import com.intellij.openapi.vcs.VcsConfiguration;
 import com.intellij.openapi.vcs.changes.actions.diff.ShowDiffFromLocalChangesActionProvider;
 import com.intellij.openapi.vcs.changes.shelf.ShelveChangesManager;
 import com.intellij.openapi.vcs.changes.ui.*;
@@ -39,7 +42,6 @@ import com.intellij.ui.components.JBLabel;
 import com.intellij.ui.components.panels.Wrapper;
 import com.intellij.ui.content.Content;
 import com.intellij.util.*;
-import com.intellij.util.concurrency.annotations.RequiresBackgroundThread;
 import com.intellij.util.concurrency.annotations.RequiresEdt;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.messages.MessageBusConnection;
@@ -47,23 +49,17 @@ import com.intellij.util.ui.JBDimension;
 import com.intellij.util.ui.JBUI;
 import com.intellij.util.ui.UIUtil;
 import com.intellij.util.ui.components.BorderLayoutPanel;
-import com.intellij.util.ui.tree.TreeUtil;
 import com.intellij.vcs.commit.*;
-import com.intellij.vcsUtil.VcsUtil;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.Nls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import javax.swing.*;
-import javax.swing.tree.DefaultMutableTreeNode;
-import javax.swing.tree.DefaultTreeModel;
-import javax.swing.tree.TreePath;
 import java.awt.*;
 import java.util.ArrayList;
 import java.util.EventListener;
 import java.util.List;
-import java.util.Objects;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 
@@ -71,26 +67,24 @@ import static com.intellij.openapi.vcs.changes.ui.ChangesViewContentManager.*;
 import static com.intellij.openapi.vcs.changes.ui.ChangesViewContentManagerKt.isCommitToolWindowShown;
 import static com.intellij.openapi.vcs.changes.ui.ChangesViewContentManagerKt.subscribeOnVcsToolWindowLayoutChanges;
 import static com.intellij.util.ui.JBUI.Panels.simplePanel;
-import static java.util.Arrays.asList;
 
 public class ChangesViewManager implements ChangesViewEx, Disposable {
   private static final String CHANGES_VIEW_PREVIEW_SPLITTER_PROPORTION = "ChangesViewManager.DETAILS_SPLITTER_PROPORTION";
 
   private final @NotNull Project myProject;
 
-  private @Nullable CommitChangesViewWithToolbarPanel myChangesPanel;
+  private @Nullable BackendChangesView myChangesView;
   private @Nullable ChangesViewToolWindowPanel myToolWindowPanel;
 
   @NotNull
   @RequiresEdt
-  CommitChangesViewWithToolbarPanel initChangesPanel() {
-    if (myChangesPanel == null) {
+  BackendChangesView initChangesView() {
+    if (myChangesView == null) {
       Activity activity = StartUpMeasurer.startActivity("ChangesViewPanel initialization");
-      ChangesListView tree = new LocalChangesListView(myProject);
-      myChangesPanel = new CommitChangesViewWithToolbarPanel(tree, this);
+      myChangesView = BackendChangesView.create(myProject, this);
       activity.end();
     }
-    return myChangesPanel;
+    return myChangesView;
   }
 
   @RequiresEdt
@@ -98,9 +92,9 @@ public class ChangesViewManager implements ChangesViewEx, Disposable {
     if (myToolWindowPanel == null) {
       Activity activity = StartUpMeasurer.startActivity("ChangesViewToolWindowPanel initialization");
 
-      // ChangesViewPanel is used for a singular ChangesViewToolWindowPanel instance. Cleanup is not needed.
-      CommitChangesViewWithToolbarPanel changesViewPanel = initChangesPanel();
-      ChangesViewToolWindowPanel panel = new ChangesViewToolWindowPanel(myProject, changesViewPanel);
+      BackendChangesView changesView = initChangesView();
+      ChangesViewToolWindowPanel panel = new ChangesViewToolWindowPanel(myProject, changesView);
+      Disposer.register(this, changesView);
       Disposer.register(this, panel);
 
       panel.updateCommitWorkflow();
@@ -108,7 +102,7 @@ public class ChangesViewManager implements ChangesViewEx, Disposable {
       myToolWindowPanel = panel;
       Disposer.register(panel, () -> {
         // Content is removed from TW
-        myChangesPanel = null;
+        myChangesView = null;
         myToolWindowPanel = null;
       });
 
@@ -182,27 +176,26 @@ public class ChangesViewManager implements ChangesViewEx, Disposable {
 
   @Override
   public void scheduleRefresh(@NotNull Runnable callback) {
-    if (myToolWindowPanel != null) {
-      myToolWindowPanel.scheduleRefreshNow(callback);
-    }
+    if (myChangesView == null) return;
+    myChangesView.getViewModel().scheduleRefreshNow(callback);
   }
 
   @Override
   public void scheduleRefresh() {
-    if (myToolWindowPanel == null) return;
-    myToolWindowPanel.scheduleRefresh();
+    if (myChangesView == null) return;
+    myChangesView.getViewModel().scheduleDelayedRefresh();
   }
 
   @Override
   public void selectFile(VirtualFile vFile) {
-    if (myToolWindowPanel == null) return;
-    myToolWindowPanel.selectFile(vFile);
+    if (myChangesView == null) return;
+    myChangesView.getViewModel().selectFile(vFile);
   }
 
   @Override
   public void selectChanges(@NotNull List<? extends Change> changes) {
-    if (myToolWindowPanel == null) return;
-    myToolWindowPanel.selectChanges(changes);
+    if (myChangesView == null) return;
+    myChangesView.getViewModel().selectChanges(new ArrayList<>(changes));
   }
 
   @Override
@@ -213,14 +206,14 @@ public class ChangesViewManager implements ChangesViewEx, Disposable {
 
   @Override
   public void setBusy(boolean b) {
-    if (myToolWindowPanel == null) return;
-    myToolWindowPanel.myChangesPanel.setBusy(b);
+    if (myChangesView == null) return;
+    myChangesView.getViewModel().setBusy(b);
   }
 
   @Override
   public void setGrouping(@NotNull String groupingKey) {
-    if (myToolWindowPanel == null) return;
-    myToolWindowPanel.myChangesPanel.setGrouping(groupingKey);
+    if (myChangesView == null) return;
+    myChangesView.getViewModel().setGrouping(groupingKey);
   }
 
   private void updateCommitWorkflow() {
@@ -241,8 +234,8 @@ public class ChangesViewManager implements ChangesViewEx, Disposable {
 
   @Override
   public void resetViewImmediatelyAndRefreshLater() {
-    if (myToolWindowPanel != null) {
-      myToolWindowPanel.myChangesPanel.resetViewImmediatelyAndRefreshLater();
+    if (myChangesView != null) {
+      myChangesView.getViewModel().resetViewImmediatelyAndRefreshLater();
     }
   }
 
@@ -273,7 +266,7 @@ public class ChangesViewManager implements ChangesViewEx, Disposable {
 
       content.setHelpId(ChangesListView.HELP_ID);
       content.setComponent(panel);
-      content.setPreferredFocusableComponent(panel.myView);
+      content.setPreferredFocusableComponent(panel.myChangesView.getViewModel().getPreferredFocusableComponent());
     }
   }
 
@@ -328,8 +321,8 @@ public class ChangesViewManager implements ChangesViewEx, Disposable {
 
     private final @NotNull Wrapper myMainPanelContent;
     private final @NotNull BorderLayoutPanel myContentPanel;
-    private final @NotNull CommitChangesViewWithToolbarPanel myChangesPanel;
-    private final @NotNull ChangesListView myView;
+
+    private final @NotNull BackendChangesView myChangesView;
 
     private final @NotNull ChangesViewCommitPanelSplitter myCommitPanelSplitter;
     private final @NotNull ChangesViewEditorDiffPreview myEditorDiffPreview;
@@ -345,18 +338,16 @@ public class ChangesViewManager implements ChangesViewEx, Disposable {
     private boolean myDisposed = false;
 
     private ChangesViewToolWindowPanel(@NotNull Project project,
-                                       @NotNull CommitChangesViewWithToolbarPanel changesViewPanel) {
+                                       @NotNull BackendChangesView backendChangesView) {
       super(false, true);
       myProject = project;
       myChangesViewSettings = ChangesViewSettings.getInstance(project);
-      myChangesPanel = changesViewPanel;
-      changesViewPanel.initPanel(new ModelProvider(project, () -> myCommitWorkflowHandler));
+      myChangesView = backendChangesView;
+      myChangesView.getViewModel().initPanel();
 
       MessageBusConnection busConnection = myProject.getMessageBus().connect(this);
       myVcsConfiguration = VcsConfiguration.getInstance(myProject);
 
-      // ChangesViewPanel is used for a singular ChangesViewToolWindowPanel instance. Cleanup is not needed.
-      myView = myChangesPanel.getChangesView();
       registerShortcuts(this);
 
       ApplicationManager.getApplication().getMessageBus().connect(project)
@@ -372,14 +363,14 @@ public class ChangesViewManager implements ChangesViewEx, Disposable {
 
       myCommitPanelSplitter = new ChangesViewCommitPanelSplitter(myProject);
       Disposer.register(this, myCommitPanelSplitter);
-      myCommitPanelSplitter.setFirstComponent(myChangesPanel);
+      myCommitPanelSplitter.setFirstComponent(backendChangesView.getChangesPanel());
 
       myContentPanel = new BorderLayoutPanel() {
         @Override
         public Dimension getMinimumSize() {
-          return isMinimumSizeSet() || myChangesPanel.isToolbarHorizontal()
+          return isMinimumSizeSet() || myChangesView.getViewModel().isToolbarHorizontal()
                  ? super.getMinimumSize()
-                 : myChangesPanel.getToolbar().getComponent().getPreferredSize();
+                 : myChangesView.getViewModel().getToolbarComponent().getPreferredSize();
         }
       };
       myContentPanel.addToCenter(myCommitPanelSplitter);
@@ -391,17 +382,17 @@ public class ChangesViewManager implements ChangesViewEx, Disposable {
       Disposer.register(this, myEditorDiffPreview);
 
       // Override the handlers registered by editorDiffPreview
-      myView.setDoubleClickHandler(e -> {
-        if (EditSourceOnDoubleClickHandler.isToggleEvent(myView, e)) return false;
+      myChangesView.getViewModel().getTree().setDoubleClickHandler(e -> {
+        if (EditSourceOnDoubleClickHandler.isToggleEvent(myChangesView.getViewModel().getTree(), e)) return false;
         if (performHoverAction()) return true;
         if (myEditorDiffPreview.handleDoubleClick(e)) return true;
-        OpenSourceUtil.openSourcesFrom(DataManager.getInstance().getDataContext(myView), true);
+        OpenSourceUtil.openSourcesFrom(DataManager.getInstance().getDataContext(myChangesView.getViewModel().getTree()), true);
         return true;
       });
-      myView.setEnterKeyHandler(e -> {
+      myChangesView.getViewModel().getTree().setEnterKeyHandler(e -> {
         if (performHoverAction()) return true;
         if (myEditorDiffPreview.handleEnterKey()) return true;
-        OpenSourceUtil.openSourcesFrom(DataManager.getInstance().getDataContext(myView), false);
+        OpenSourceUtil.openSourcesFrom(DataManager.getInstance().getDataContext(myChangesView.getViewModel().getTree()), false);
         return true;
       });
 
@@ -412,7 +403,7 @@ public class ChangesViewManager implements ChangesViewEx, Disposable {
     }
 
     private boolean performHoverAction() {
-      ChangesBrowserNode<?> selected = VcsTreeModelData.selected(myView).iterateNodes().single();
+      ChangesBrowserNode<?> selected = VcsTreeModelData.selected(myChangesView.getViewModel().getTree()).iterateNodes().single();
       if (selected == null) return false;
 
       for (ChangesViewNodeAction extension : ChangesViewNodeAction.EP_NAME.getExtensions(myProject)) {
@@ -453,7 +444,7 @@ public class ChangesViewManager implements ChangesViewEx, Disposable {
 
     private class ChangesViewEditorDiffPreview extends TreeHandlerEditorDiffPreview {
       private ChangesViewEditorDiffPreview() {
-        super(myView, myContentPanel, ChangesViewDiffPreviewHandler.INSTANCE);
+        super(myChangesView.getViewModel().getTree(), myContentPanel, ChangesViewDiffPreviewHandler.INSTANCE);
       }
 
       @Override
@@ -491,7 +482,7 @@ public class ChangesViewManager implements ChangesViewEx, Disposable {
 
       @Override
       protected boolean isOpenPreviewWithSingleClick() {
-        if (myChangesPanel.getChangesView().isModelUpdateInProgress()) return false;
+        if (myChangesView.getViewModel().isModelUpdateInProgress()) return false;
         if (mySplitterDiffPreview != null && myVcsConfiguration.LOCAL_CHANGES_DETAILS_PREVIEW_SHOWN) return false;
         return super.isOpenPreviewWithSingleClick();
       }
@@ -544,8 +535,7 @@ public class ChangesViewManager implements ChangesViewEx, Disposable {
     }
 
     private ChangesViewDiffPreviewProcessor createDiffPreviewProcessor(boolean isInEditor) {
-
-      ChangesViewDiffPreviewProcessor processor = new ChangesViewDiffPreviewProcessor(myView, isInEditor);
+      ChangesViewDiffPreviewProcessor processor = new ChangesViewDiffPreviewProcessor(myChangesView.getViewModel().getTree(), isInEditor);
       this.addListener(new Listener() {
         @Override
         public void allowExcludeFromCommitChanged() {
@@ -583,6 +573,7 @@ public class ChangesViewManager implements ChangesViewEx, Disposable {
         myCommitWorkflowHandler = null;
         myCommitPanel = null;
       }
+      myChangesView.getViewModel().setCommitWorkflowHandler(myCommitWorkflowHandler);
 
       myDispatcher.getMulticaster().allowExcludeFromCommitChanged();
       configureToolbars();
@@ -598,12 +589,12 @@ public class ChangesViewManager implements ChangesViewEx, Disposable {
 
     private void configureToolbars() {
       boolean isToolbarHorizontal = CommitModeManager.getInstance(myProject).getCurrentCommitMode().useCommitToolWindow();
-      myChangesPanel.setToolbarHorizontal(isToolbarHorizontal);
+      myChangesView.getViewModel().setToolbarHorizontal(isToolbarHorizontal);
     }
 
     @Override
     public @NotNull List<AnAction> getActions(boolean originalProvider) {
-      return asList(myChangesPanel.getToolbarActionGroup().getChildren(ActionManager.getInstance()));
+      return myChangesView.getViewModel().getActions();
     }
 
     @Override
@@ -611,7 +602,7 @@ public class ChangesViewManager implements ChangesViewEx, Disposable {
       super.uiDataSnapshot(sink);
       sink.set(DiffDataKeys.EDITOR_TAB_DIFF_PREVIEW, myEditorDiffPreview);
       sink.set(ChangesViewDataKeys.SETTINGS, myChangesViewSettings);
-      sink.set(ChangesViewDataKeys.REFRESHER, () -> scheduleRefreshNow(null));
+      sink.set(ChangesViewDataKeys.REFRESHER, () -> myChangesView.getViewModel().scheduleRefreshNow(null));
 
       // This makes COMMIT_WORKFLOW_HANDLER available anywhere in "Local Changes" - so commit executor actions are enabled.
       DataSink.uiDataSnapshot(sink, myCommitPanel);
@@ -638,42 +629,6 @@ public class ChangesViewManager implements ChangesViewEx, Disposable {
       });
     }
 
-    public void scheduleRefresh() {
-      myChangesPanel.scheduleRefresh();
-    }
-
-    private void scheduleRefreshNow(@Nullable @RequiresBackgroundThread Runnable callback) {
-      myChangesPanel.scheduleRefreshNow(callback);
-    }
-
-    public void selectFile(@Nullable VirtualFile vFile) {
-      if (vFile == null) return;
-
-      ChangesBrowserNode<?> node = findNodeForFile(vFile);
-      if (node == null) return;
-
-      TreeUtil.selectNode(myView, node);
-    }
-
-    public void selectChanges(@NotNull List<? extends Change> changes) {
-      List<TreePath> paths = new ArrayList<>();
-
-      for (Change change : changes) {
-        ContainerUtil.addIfNotNull(paths, myView.findNodePathInTree(change));
-      }
-
-      TreeUtil.selectPaths(myView, paths);
-    }
-
-    private @Nullable ChangesBrowserNode<?> findNodeForFile(@NotNull VirtualFile file) {
-      FilePath filePath = VcsUtil.getFilePath(file);
-      DefaultMutableTreeNode root = (DefaultMutableTreeNode)myView.getModel().getRoot();
-      return (ChangesBrowserNode<?>)TreeUtil.findNode(root, node -> {
-        FilePath nodeFilePath = VcsTreeModelData.mapUserObjectToFilePath(node.getUserObject());
-        return Objects.equals(filePath, nodeFilePath);
-      });
-    }
-
     private void invokeLaterIfNeeded(Runnable runnable) {
       ModalityUiUtil.invokeLaterIfNeeded(ModalityState.nonModal(), myProject.getDisposed(), runnable);
     }
@@ -693,43 +648,6 @@ public class ChangesViewManager implements ChangesViewEx, Disposable {
     return ChangesViewWorkflowManager.getInstance(myProject).getCommitWorkflowHandler();
   }
 
-  private static class ModelProvider implements CommitChangesViewWithToolbarPanel.ModelProvider {
-    private final @NotNull Project project;
-    private final @NotNull Supplier<@Nullable ChangesViewCommitWorkflowHandler> commitWorkflowHandlerSupplier;
-
-    private ModelProvider(@NotNull Project project,
-                          @NotNull Supplier<@Nullable ChangesViewCommitWorkflowHandler> commitWorkflowHandlerSupplier) {
-      this.project = project;
-      this.commitWorkflowHandlerSupplier = commitWorkflowHandlerSupplier;
-    }
-
-    @Override
-    public @NotNull ExtendedTreeModel getModel(@NotNull ChangesGroupingPolicyFactory grouping) {
-      ChangeListManagerImpl changeListManager = ChangeListManagerImpl.getInstanceImpl(project);
-      List<LocalChangeList> changeLists = changeListManager.getChangeLists();
-      List<FilePath> unversionedFiles = changeListManager.getUnversionedFilesPaths();
-
-      DefaultTreeModel treeModel = ChangesViewUtil.INSTANCE.createTreeModel(
-        project,
-        grouping,
-        changeLists,
-        unversionedFiles,
-        ChangesViewSettings.getInstance(project).getShowIgnored(),
-        () -> isAllowExcludeFromCommit(commitWorkflowHandlerSupplier.get())
-      );
-      return new ExtendedTreeModel(changeLists, unversionedFiles, treeModel);
-    }
-
-    @Override
-    public void synchronizeInclusion(@NotNull List<? extends @NotNull LocalChangeList> changeLists,
-                                     @NotNull List<? extends @NotNull FilePath> unversionedFiles) {
-      ChangesViewCommitWorkflowHandler commitWorkflowHandler = commitWorkflowHandlerSupplier.get();
-      if (commitWorkflowHandler != null) {
-        commitWorkflowHandler.synchronizeInclusion(changeLists, unversionedFiles);
-      }
-    }
-  }
-
   private static boolean isAllowExcludeFromCommit(@Nullable ChangesViewCommitWorkflowHandler handler) {
     return handler != null && handler.isActive();
   }

platform/vcs-impl/src/com/intellij/openapi/vcs/changes/ChangesViewWorkflowManagerImpl.kt

@@ -40,9 +40,9 @@ internal class ChangesViewWorkflowManagerImpl(
         val activity = StartUpMeasurer.startActivity("ChangesViewWorkflowManager initialization")
 
         // ChangesViewPanel can be reused between workflow instances -> should clean up after ourselves
-        val changesPanel = (ChangesViewManager.getInstance(project) as ChangesViewManager).initChangesPanel()
+        val changesView = (ChangesViewManager.getInstance(project) as ChangesViewManager).initChangesView()
         val workflow = ChangesViewCommitWorkflow(project)
-        val commitPanel = ChangesViewCommitPanel(project, changesPanel.changesView)
+        val commitPanel = ChangesViewCommitPanel(project, changesView.viewModel.getTree())
         _commitWorkflowHandler = ChangesViewCommitWorkflowHandler(workflow, commitPanel)
 
         project.messageBus.syncPublisher(TOPIC).commitWorkflowChanged()