From 9ade171cbfd84e50fff0ee50bc52685ff912c00d Mon Sep 17 00:00:00 2001 From: "Ilia.Shulgin" Date: Tue, 23 Sep 2025 22:58:31 +0200 Subject: [PATCH] [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 | 3 - .../changes/BackendCommitChangesViewModel.kt | 156 +++++++++++++++ .../vcs/changes/ChangesViewManager.java | 180 +++++------------- .../changes/ChangesViewWorkflowManagerImpl.kt | 4 +- 4 files changed, 207 insertions(+), 136 deletions(-) create mode 100644 platform/vcs-impl/src/com/intellij/openapi/vcs/changes/BackendCommitChangesViewModel.kt diff --git a/platform/vcs-impl/api-dump.txt b/platform/vcs-impl/api-dump.txt index 3cf7f15b4611..910a1266e49a 100644 --- a/platform/vcs-impl/api-dump.txt +++ b/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 diff --git a/platform/vcs-impl/src/com/intellij/openapi/vcs/changes/BackendCommitChangesViewModel.kt b/platform/vcs-impl/src/com/intellij/openapi/vcs/changes/BackendCommitChangesViewModel.kt new file mode 100644 index 000000000000..052e40715f86 --- /dev/null +++ b/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 + 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) + + @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 = 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) { + val paths: MutableList = 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, unversionedFiles: List) { + commitWorkflowHandler?.synchronizeInclusion(changeLists, unversionedFiles) + } + } +} diff --git a/platform/vcs-impl/src/com/intellij/openapi/vcs/changes/ChangesViewManager.java b/platform/vcs-impl/src/com/intellij/openapi/vcs/changes/ChangesViewManager.java index 0dbc571a5acc..fa637f675410 100644 --- a/platform/vcs-impl/src/com/intellij/openapi/vcs/changes/ChangesViewManager.java +++ b/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 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 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 changes) { - List 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 changeLists = changeListManager.getChangeLists(); - List 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 changeLists, - @NotNull List unversionedFiles) { - ChangesViewCommitWorkflowHandler commitWorkflowHandler = commitWorkflowHandlerSupplier.get(); - if (commitWorkflowHandler != null) { - commitWorkflowHandler.synchronizeInclusion(changeLists, unversionedFiles); - } - } - } - private static boolean isAllowExcludeFromCommit(@Nullable ChangesViewCommitWorkflowHandler handler) { return handler != null && handler.isActive(); } diff --git a/platform/vcs-impl/src/com/intellij/openapi/vcs/changes/ChangesViewWorkflowManagerImpl.kt b/platform/vcs-impl/src/com/intellij/openapi/vcs/changes/ChangesViewWorkflowManagerImpl.kt index 96d29e0a784f..87ae4715ef44 100644 --- a/platform/vcs-impl/src/com/intellij/openapi/vcs/changes/ChangesViewWorkflowManagerImpl.kt +++ b/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()