nieldw.plugins.idea.ChooseComponentsToImportDialog.java Source code

Introduction

Here is the source code for nieldw.plugins.idea.ChooseComponentsToImportDialog.java

Source

/*
 * Copyright 2000-2012 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 nieldw.plugins.idea;

import com.intellij.ide.util.ElementsChooser;
import com.intellij.openapi.components.ExportableComponent;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.ui.DialogWrapper;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.util.text.StringUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.io.File;
import java.util.*;
import java.util.List;

public class ChooseComponentsToImportDialog extends DialogWrapper {
    private static Logger LOG = Logger.getInstance("#com.intellij.ide.actions.ChooseComponentsToExportDialog");

    private ElementsChooser<ComponentElementProperties> myChooser;
    private String myDescription;

    public ChooseComponentsToImportDialog(List<ExportableComponent> components,
            Map<File, Set<ExportableComponent>> fileToComponents, String title, String description) {
        super(false);
        myDescription = description;
        Map<ExportableComponent, ComponentElementProperties> componentToContainingListElement = new LinkedHashMap<ExportableComponent, ComponentElementProperties>();

        for (ExportableComponent component : components) {
            if (!addToExistingListElement(component, componentToContainingListElement, fileToComponents)) {
                ComponentElementProperties componentElementProperties = new ComponentElementProperties();
                componentElementProperties.addComponent(component);

                componentToContainingListElement.put(component, componentElementProperties);
            }
        }
        Set<ComponentElementProperties> componentElementProperties = new LinkedHashSet<ComponentElementProperties>(
                componentToContainingListElement.values());
        myChooser = new ElementsChooser<ComponentElementProperties>(true);
        myChooser.setColorUnmarkedElements(false);
        for (ComponentElementProperties componentElementProperty : componentElementProperties) {
            myChooser.addElement(componentElementProperty, true, componentElementProperty);
        }
        myChooser.sort(new Comparator<ComponentElementProperties>() {
            @Override
            public int compare(ComponentElementProperties o1, ComponentElementProperties o2) {
                return o1.toString().compareTo(o2.toString());
            }
        });

        updateControls();

        setTitle(title);
        init();
    }

    private void updateControls() {
        //    setOKActionEnabled(!StringUtil.isEmptyOrSpaces(myPathPanel.getText()));
    }

    @NotNull
    @Override
    protected Action[] createLeftSideActions() {
        AbstractAction selectAll = new AbstractAction("Select &All") {
            private static final long serialVersionUID = 7662396448754079366L;

            @Override
            public void actionPerformed(ActionEvent e) {
                myChooser.setAllElementsMarked(true);
            }
        };
        AbstractAction selectNone = new AbstractAction("Select &None") {
            private static final long serialVersionUID = 495778077017007423L;

            @Override
            public void actionPerformed(ActionEvent e) {
                myChooser.setAllElementsMarked(false);
            }
        };
        AbstractAction invert = new AbstractAction("&Invert") {
            private static final long serialVersionUID = 2519996846700328407L;

            @Override
            public void actionPerformed(ActionEvent e) {
                //        myChooser.invertSelection();
            }
        };
        return new Action[] { selectAll, selectNone, invert };
    }

    private static boolean addToExistingListElement(ExportableComponent component,
            Map<ExportableComponent, ComponentElementProperties> componentToContainingListElement,
            Map<File, Set<ExportableComponent>> fileToComponents) {
        File[] exportFiles = component.getExportFiles();
        File file = null;
        for (File exportFile : exportFiles) {
            Set<ExportableComponent> tiedComponents = fileToComponents.get(exportFile);

            for (ExportableComponent tiedComponent : tiedComponents) {
                if (tiedComponent == component)
                    continue;
                ComponentElementProperties elementProperties = componentToContainingListElement.get(tiedComponent);
                if (elementProperties != null && !FileUtil.filesEqual(exportFile, file)) {
                    LOG.assertTrue(file == null,
                            "Component " + component + " serialize itself into " + file + " and " + exportFile);
                    // found
                    elementProperties.addComponent(component);
                    componentToContainingListElement.put(component, elementProperties);
                    file = exportFile;
                }
            }
        }
        return file != null;
    }

    @Override
    protected JComponent createNorthPanel() {
        return new JLabel(myDescription);
    }

    @Override
    protected JComponent createCenterPanel() {
        return myChooser;
    }

    @Override
    protected JComponent createSouthPanel() {
        return super.createSouthPanel();
    }

    Set<ExportableComponent> getExportableComponents() {
        List<ComponentElementProperties> markedElements = myChooser.getMarkedElements();
        Set<ExportableComponent> components = new HashSet<ExportableComponent>();
        for (ComponentElementProperties elementProperties : markedElements) {
            components.addAll(elementProperties.myComponents);
        }
        return components;
    }

    private static class ComponentElementProperties implements ElementsChooser.ElementProperties {
        private Set<ExportableComponent> myComponents = new HashSet<ExportableComponent>();

        private boolean addComponent(ExportableComponent component) {
            return myComponents.add(component);
        }

        @Override
        @Nullable
        public Icon getIcon() {
            return null;
        }

        @Override
        @Nullable
        public Color getColor() {
            return null;
        }

        public String toString() {
            Set<String> names = new LinkedHashSet<String>();

            for (ExportableComponent component : myComponents) {
                names.add(component.getPresentableName());
            }

            return StringUtil.join(names.toArray(new String[names.size()]), ", ");
        }
    }

    @Override
    protected String getDimensionServiceKey() {
        return "#com.intellij.ide.actions.ChooseComponentsToExportDialog";
    }
}