5cc936562800a1c6f471ceee605c0f988396c254
[idea/community.git] / java / idea-ui / src / com / intellij / openapi / roots / ui / configuration / classpath / ClasspathTableModel.java
1 /*
2  * Copyright 2000-2011 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.openapi.roots.ui.configuration.classpath;
17
18 import com.intellij.ide.JavaUiBundle;
19 import com.intellij.openapi.roots.DependencyScope;
20 import com.intellij.openapi.roots.JdkOrderEntry;
21 import com.intellij.openapi.roots.ModifiableRootModel;
22 import com.intellij.openapi.roots.OrderEntry;
23 import com.intellij.openapi.roots.ui.configuration.ModuleConfigurationState;
24 import com.intellij.openapi.roots.ui.configuration.projectRoot.StructureConfigurableContext;
25 import com.intellij.openapi.util.Comparing;
26 import com.intellij.util.ui.ColumnInfo;
27 import com.intellij.util.ui.ItemRemovable;
28 import com.intellij.util.ui.ListTableModel;
29 import org.jetbrains.annotations.Nullable;
30
31 import javax.swing.*;
32 import java.util.ArrayList;
33 import java.util.Collections;
34 import java.util.Comparator;
35 import java.util.List;
36
37 class ClasspathTableModel extends ListTableModel<ClasspathTableItem<?>> implements ItemRemovable {
38   private static final ColumnInfo<ClasspathTableItem<?>, Boolean> EXPORT_COLUMN_INFO = new ColumnInfo<ClasspathTableItem<?>, Boolean>(
39     getExportColumnName()) {
40     @Nullable
41     @Override
42     public Boolean valueOf(ClasspathTableItem<?> item) {
43       return item.isExported();
44     }
45
46     @Override
47     public void setValue(ClasspathTableItem<?> item, Boolean value) {
48       item.setExported(value);
49     }
50
51     @Override
52     public boolean isCellEditable(ClasspathTableItem<?> item) {
53       return item.isExportable();
54     }
55
56     @Override
57     public Class getColumnClass() {
58       return Boolean.class;
59     }
60   };
61   private static final Comparator<DependencyScope> DEPENDENCY_SCOPE_COMPARATOR =
62     (o1, o2) -> o1.getDisplayName().compareToIgnoreCase(o2.getDisplayName());
63   private static final Comparator<ClasspathTableItem<?>> CLASSPATH_ITEM_SCOPE_COMPARATOR =
64     (o1, o2) -> Comparing.compare(o1.getScope(), o2.getScope(), DEPENDENCY_SCOPE_COMPARATOR);
65   private static final ColumnInfo<ClasspathTableItem<?>, DependencyScope> SCOPE_COLUMN_INFO = new ColumnInfo<ClasspathTableItem<?>, DependencyScope>(
66     getScopeColumnName()) {
67     @Nullable
68     @Override
69     public DependencyScope valueOf(ClasspathTableItem<?> item) {
70       return item.getScope();
71     }
72
73     @Override
74     public void setValue(ClasspathTableItem<?> item, DependencyScope value) {
75       item.setScope(value);
76     }
77
78     @Override
79     public boolean isCellEditable(ClasspathTableItem<?> item) {
80       return item.isExportable();
81     }
82
83     @Override
84     public Class getColumnClass() {
85       return DependencyScope.class;
86     }
87
88     @Nullable
89     @Override
90     public Comparator<ClasspathTableItem<?>> getComparator() {
91       return CLASSPATH_ITEM_SCOPE_COMPARATOR;
92     }
93   };
94   public static final int EXPORT_COLUMN = 0;
95   public static final int ITEM_COLUMN = 1;
96   public static final int SCOPE_COLUMN = 2;
97   private final ModuleConfigurationState myState;
98   private final StructureConfigurableContext myContext;
99
100   ClasspathTableModel(final ModuleConfigurationState state, StructureConfigurableContext context) {
101     super(EXPORT_COLUMN_INFO, new ClasspathTableItemClasspathColumnInfo(context), SCOPE_COLUMN_INFO);
102     myState = state;
103     myContext = context;
104     init();
105   }
106
107   @Override
108   public RowSorter.SortKey getDefaultSortKey() {
109     return new RowSorter.SortKey(1, SortOrder.UNSORTED);
110   }
111
112   private ModifiableRootModel getModel() {
113     return myState.getRootModel();
114   }
115
116   public void init() {
117     final OrderEntry[] orderEntries = getModel().getOrderEntries();
118     boolean hasJdkOrderEntry = false;
119     List<ClasspathTableItem<?>> items = new ArrayList<>();
120     for (final OrderEntry orderEntry : orderEntries) {
121       if (orderEntry instanceof JdkOrderEntry) {
122         hasJdkOrderEntry = true;
123       }
124       items.add(ClasspathTableItem.createItem(orderEntry, myContext));
125     }
126     if (!hasJdkOrderEntry) {
127       items.add(0, new InvalidJdkItem());
128     }
129     setItems(items);
130   }
131
132   @Override
133   public void exchangeRows(int idx1, int idx2) {
134     super.exchangeRows(idx1, idx2);
135     List<OrderEntry> entries = getEntries();
136     myState.getRootModel().rearrangeOrderEntries(entries.toArray(OrderEntry.EMPTY_ARRAY));
137   }
138
139   public void clear() {
140     setItems(Collections.emptyList());
141   }
142
143   private List<OrderEntry> getEntries() {
144     final int count = getRowCount();
145     final List<OrderEntry> entries = new ArrayList<>(count);
146     for (int row = 0; row < count; row++) {
147       final OrderEntry entry = getItem(row).getEntry();
148       if (entry != null) {
149         entries.add(entry);
150       }
151     }
152     return entries;
153   }
154
155   private static class ClasspathTableItemClasspathColumnInfo extends ColumnInfo<ClasspathTableItem<?>, ClasspathTableItem<?>> {
156     private final Comparator<ClasspathTableItem<?>> myItemComparator;
157
158     ClasspathTableItemClasspathColumnInfo(final StructureConfigurableContext context) {
159       super("");
160       myItemComparator = (o1, o2) -> {
161         String text1 = ClasspathPanelImpl.getCellAppearance(o1, context, false).getText();
162         String text2 = ClasspathPanelImpl.getCellAppearance(o2, context, false).getText();
163         return text1.compareToIgnoreCase(text2);
164       };
165     }
166
167     @Nullable
168     @Override
169     public Comparator<ClasspathTableItem<?>> getComparator() {
170       return myItemComparator;
171     }
172
173     @Nullable
174     @Override
175     public ClasspathTableItem<?> valueOf(ClasspathTableItem<?> item) {
176       return item;
177     }
178
179     @Override
180     public Class getColumnClass() {
181       return ClasspathTableItem.class;
182     }
183   }
184
185   private static String getScopeColumnName() {
186     return JavaUiBundle.message("modules.order.export.scope.column");
187   }
188
189   static String getExportColumnName() {
190     return JavaUiBundle.message("modules.order.export.export.column");
191   }
192 }