| /* |
| * Copyright 2000-2009 JetBrains s.r.o. |
| * |
| * 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.intellij.ide.util.newProjectWizard.impl; |
| |
| import com.intellij.facet.impl.ui.libraries.FrameworkLibraryProvider; |
| import com.intellij.framework.FrameworkVersion; |
| import com.intellij.framework.addSupport.FrameworkSupportInModuleProvider; |
| import com.intellij.framework.addSupport.FrameworkVersionListener; |
| import com.intellij.ide.util.frameworkSupport.FrameworkSupportConfigurable; |
| import com.intellij.ide.util.frameworkSupport.FrameworkSupportModel; |
| import com.intellij.ide.util.frameworkSupport.FrameworkSupportModelListener; |
| import com.intellij.ide.util.frameworkSupport.FrameworkSupportProvider; |
| import com.intellij.ide.util.newProjectWizard.FrameworkSupportNode; |
| import com.intellij.ide.util.newProjectWizard.FrameworkSupportNodeBase; |
| import com.intellij.ide.util.newProjectWizard.FrameworkSupportOptionsComponent; |
| import com.intellij.ide.util.newProjectWizard.OldFrameworkSupportProviderWrapper; |
| import com.intellij.ide.util.projectWizard.ModuleBuilder; |
| import com.intellij.openapi.Disposable; |
| import com.intellij.openapi.project.Project; |
| import com.intellij.openapi.roots.ui.configuration.projectRoot.LibrariesContainer; |
| import com.intellij.openapi.util.Comparing; |
| import com.intellij.openapi.util.UserDataHolderBase; |
| import com.intellij.util.EventDispatcher; |
| import org.jetbrains.annotations.NonNls; |
| import org.jetbrains.annotations.NotNull; |
| import org.jetbrains.annotations.Nullable; |
| |
| import java.util.HashMap; |
| import java.util.Map; |
| |
| /** |
| * @author nik |
| */ |
| public abstract class FrameworkSupportModelBase extends UserDataHolderBase implements FrameworkSupportModel { |
| private final Project myProject; |
| private final ModuleBuilder myModuleBuilder; |
| private final LibrariesContainer myLibrariesContainer; |
| private final EventDispatcher<FrameworkSupportModelListener> myDispatcher = EventDispatcher.create(FrameworkSupportModelListener.class); |
| private final EventDispatcher<FrameworkVersionListener> myVersionEventDispatcher = EventDispatcher.create(FrameworkVersionListener.class); |
| private final Map<String, FrameworkSupportNode> mySettingsMap = new HashMap<String, FrameworkSupportNode>(); |
| private final Map<String, FrameworkSupportOptionsComponent> myOptionsComponentsMap = new HashMap<String, FrameworkSupportOptionsComponent>(); |
| private final Map<String, FrameworkVersion> mySelectedVersions = new HashMap<String, FrameworkVersion>(); |
| private final Map<String, String> myFrameworkVersions = new HashMap<String, String>(); |
| private FrameworkLibraryProvider myLibraryProvider; |
| |
| public FrameworkSupportModelBase(final @Nullable Project project, @Nullable ModuleBuilder builder, @NotNull LibrariesContainer librariesContainer) { |
| myProject = project; |
| myModuleBuilder = builder; |
| myLibrariesContainer = librariesContainer; |
| } |
| |
| @NotNull |
| public abstract String getBaseDirectoryForLibrariesPath(); |
| |
| public void registerComponent(@NotNull final FrameworkSupportInModuleProvider provider, @NotNull final FrameworkSupportNode node) { |
| mySettingsMap.put(provider.getFrameworkType().getId(), node); |
| } |
| |
| public void registerOptionsComponent(FrameworkSupportInModuleProvider provider, FrameworkSupportOptionsComponent component) { |
| myOptionsComponentsMap.put(provider.getFrameworkType().getId(), component); |
| } |
| |
| public Project getProject() { |
| return myProject; |
| } |
| |
| public ModuleBuilder getModuleBuilder() { |
| return myModuleBuilder; |
| } |
| |
| public boolean isFrameworkSelected(@NotNull @NonNls final String providerId) { |
| final FrameworkSupportNode node = mySettingsMap.get(providerId); |
| return node != null && node.isChecked(); |
| } |
| |
| public void addFrameworkListener(@NotNull final FrameworkSupportModelListener listener) { |
| myDispatcher.addListener(listener); |
| } |
| |
| @Override |
| public void addFrameworkListener(@NotNull final FrameworkSupportModelListener listener, @NotNull Disposable parentDisposable) { |
| myDispatcher.addListener(listener, parentDisposable); |
| } |
| |
| public void addFrameworkVersionListener(@NotNull FrameworkVersionListener listener, @NotNull Disposable parentDisposable) { |
| myVersionEventDispatcher.addListener(listener, parentDisposable); |
| } |
| |
| public void removeFrameworkListener(@NotNull final FrameworkSupportModelListener listener) { |
| myDispatcher.removeListener(listener); |
| } |
| |
| public void setFrameworkComponentEnabled(@NotNull @NonNls final String providerId, final boolean enable) { |
| final FrameworkSupportNode node = mySettingsMap.get(providerId); |
| if (node != null && enable != node.isChecked()) { |
| node.setChecked(enable); |
| // ensure configurable to be created and registered to disposer |
| node.getConfigurable(); |
| } |
| } |
| |
| @Override |
| public void updateFrameworkLibraryComponent(@NotNull String providerId) { |
| FrameworkSupportOptionsComponent component = myOptionsComponentsMap.get(providerId); |
| if (component != null) { |
| component.updateLibrariesPanel(); |
| } |
| } |
| |
| public FrameworkSupportConfigurable getFrameworkConfigurable(@NotNull @NonNls String providerId) { |
| FrameworkSupportConfigurable configurable = findFrameworkConfigurable(providerId); |
| if (configurable == null) { |
| throw new IllegalArgumentException("provider '" + providerId + "' not found"); |
| } |
| return configurable; |
| } |
| |
| @Nullable |
| @Override |
| public FrameworkSupportConfigurable findFrameworkConfigurable(@NotNull @NonNls String providerId) { |
| final FrameworkSupportNode node = mySettingsMap.get(providerId); |
| if (node == null) { |
| return null; |
| } |
| return ((OldFrameworkSupportProviderWrapper.FrameworkSupportConfigurableWrapper)node.getConfigurable()).getConfigurable(); |
| } |
| |
| public void setSelectedVersion(@NotNull String frameworkOrGroupId, @NotNull FrameworkVersion version) { |
| FrameworkVersion oldVersion = mySelectedVersions.put(frameworkOrGroupId, version); |
| if (!Comparing.equal(oldVersion, version)) { |
| for (Map.Entry<String, FrameworkSupportNode> entry : mySettingsMap.entrySet()) { |
| if (hasParentWithId(entry.getValue(), frameworkOrGroupId)) { |
| if (!entry.getValue().getId().equals(frameworkOrGroupId)) { |
| FrameworkSupportOptionsComponent component = myOptionsComponentsMap.get(entry.getKey()); |
| if (component != null) { |
| component.updateVersionsComponent(); |
| } |
| } |
| updateFrameworkLibraryComponent(entry.getKey()); |
| } |
| } |
| } |
| myVersionEventDispatcher.getMulticaster().versionChanged(version); |
| } |
| |
| private static boolean hasParentWithId(final FrameworkSupportNode node, @NotNull String frameworkOrGroupId) { |
| FrameworkSupportNodeBase current = node; |
| while (current != null) { |
| if (current.getId().equals(frameworkOrGroupId)) return true; |
| current = current.getParentNode(); |
| } |
| return false; |
| } |
| |
| public FrameworkLibraryProvider getLibraryProvider() { |
| return myLibraryProvider; |
| } |
| |
| public void setLibraryProvider(@Nullable FrameworkLibraryProvider libraryProvider) { |
| myLibraryProvider = libraryProvider; |
| for (FrameworkSupportOptionsComponent optionsComponent : myOptionsComponentsMap.values()) { |
| optionsComponent.updateLibrariesPanel(); |
| } |
| } |
| |
| @Nullable |
| public <V extends FrameworkVersion> V getSelectedVersion(@NotNull String frameworkOrGroupId) { |
| return (V)mySelectedVersions.get(frameworkOrGroupId); |
| } |
| |
| public void onFrameworkSelectionChanged(FrameworkSupportNode node) { |
| final FrameworkSupportInModuleProvider provider = node.getUserObject(); |
| //todo[nik] |
| boolean checked = node.isChecked(); |
| if (provider instanceof OldFrameworkSupportProviderWrapper) { |
| final FrameworkSupportProvider oldProvider = ((OldFrameworkSupportProviderWrapper) provider).getProvider(); |
| selectFramework(oldProvider, checked); |
| } |
| for (FrameworkSupportInModuleProvider.FrameworkDependency dependency : provider.getDependenciesFrameworkIds()) { |
| if (!dependency.isOptional()) { |
| String id = dependency.getFrameworkId(); |
| setFrameworkComponentEnabled(id, true); |
| } |
| } |
| } |
| |
| public void selectFramework(FrameworkSupportProvider provider, boolean checked) { |
| final FrameworkSupportModelListener multicaster = myDispatcher.getMulticaster(); |
| if (checked) { |
| multicaster.frameworkSelected(provider); |
| } |
| else { |
| multicaster.frameworkUnselected(provider); |
| } |
| } |
| |
| public void fireWizardStepUpdated() { |
| myDispatcher.getMulticaster().wizardStepUpdated(); |
| } |
| |
| @NotNull |
| public LibrariesContainer getLibrariesContainer() { |
| return myLibrariesContainer; |
| } |
| |
| public void setSelectedLibraryVersion(String id, String version) { |
| myFrameworkVersions.put(id, version); |
| myVersionEventDispatcher.getMulticaster().versionChanged(getSelectedVersion(id)); |
| } |
| |
| public String getFrameworkVersion(String id) { |
| FrameworkVersion version = mySelectedVersions.get(id); |
| return version == null ? myFrameworkVersions.get(id) : version.getVersionNumber(); |
| } |
| } |