'RIDER-47575 Design for Plist Editor -- icon for the button to toggle localized/raw...
[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.openapi.util.NlsContexts;
27 import com.intellij.util.ui.ColumnInfo;
28 import com.intellij.util.ui.ItemRemovable;
29 import com.intellij.util.ui.ListTableModel;
30 import org.jetbrains.annotations.NotNull;
31 import org.jetbrains.annotations.Nullable;
32
33 import javax.swing.*;
34 import java.util.ArrayList;
35 import java.util.Collections;
36 import java.util.Comparator;
37 import java.util.List;
38
39 class ClasspathTableModel extends ListTableModel<ClasspathTableItem<?>> implements ItemRemovable {
40   private static final ColumnInfo<ClasspathTableItem<?>, Boolean> EXPORT_COLUMN_INFO = new ColumnInfo<ClasspathTableItem<?>, Boolean>(getExportColumnName()) {
41     @Override
42     public @NotNull 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<Boolean> 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>(getScopeColumnName()) {
66     @Nullable
67     @Override
68     public DependencyScope valueOf(ClasspathTableItem<?> item) {
69       return item.getScope();
70     }
71
72     @Override
73     public void setValue(ClasspathTableItem<?> item, DependencyScope value) {
74       item.setScope(value);
75     }
76
77     @Override
78     public boolean isCellEditable(ClasspathTableItem<?> item) {
79       return item.isExportable();
80     }
81
82     @Override
83     public Class<DependencyScope> getColumnClass() {
84       return DependencyScope.class;
85     }
86
87     @Override
88     public @NotNull Comparator<ClasspathTableItem<?>> getComparator() {
89       return CLASSPATH_ITEM_SCOPE_COMPARATOR;
90     }
91   };
92   public static final int EXPORT_COLUMN = 0;
93   public static final int ITEM_COLUMN = 1;
94   public static final int SCOPE_COLUMN = 2;
95   private final ModuleConfigurationState myState;
96   private final StructureConfigurableContext myContext;
97
98   ClasspathTableModel(final ModuleConfigurationState state, StructureConfigurableContext context) {
99     super(EXPORT_COLUMN_INFO, new ClasspathTableItemClasspathColumnInfo(context), SCOPE_COLUMN_INFO);
100     myState = state;
101     myContext = context;
102     init();
103   }
104
105   @Override
106   public RowSorter.SortKey getDefaultSortKey() {
107     return new RowSorter.SortKey(1, SortOrder.UNSORTED);
108   }
109
110   private ModifiableRootModel getModel() {
111     return myState.getRootModel();
112   }
113
114   public void init() {
115     final OrderEntry[] orderEntries = getModel().getOrderEntries();
116     boolean hasJdkOrderEntry = false;
117     List<ClasspathTableItem<?>> items = new ArrayList<>();
118     for (final OrderEntry orderEntry : orderEntries) {
119       if (orderEntry instanceof JdkOrderEntry) {
120         hasJdkOrderEntry = true;
121       }
122       items.add(ClasspathTableItem.createItem(orderEntry, myContext));
123     }
124     if (!hasJdkOrderEntry) {
125       items.add(0, new InvalidJdkItem());
126     }
127     setItems(items);
128   }
129
130   @Override
131   public void exchangeRows(int idx1, int idx2) {
132     super.exchangeRows(idx1, idx2);
133     List<OrderEntry> entries = getEntries();
134     myState.getRootModel().rearrangeOrderEntries(entries.toArray(OrderEntry.EMPTY_ARRAY));
135   }
136
137   public void clear() {
138     setItems(Collections.emptyList());
139   }
140
141   private List<OrderEntry> getEntries() {
142     final int count = getRowCount();
143     final List<OrderEntry> entries = new ArrayList<>(count);
144     for (int row = 0; row < count; row++) {
145       final OrderEntry entry = getItem(row).getEntry();
146       if (entry != null) {
147         entries.add(entry);
148       }
149     }
150     return entries;
151   }
152
153   private static class ClasspathTableItemClasspathColumnInfo extends ColumnInfo<ClasspathTableItem<?>, ClasspathTableItem<?>> {
154     private final Comparator<ClasspathTableItem<?>> myItemComparator;
155
156     ClasspathTableItemClasspathColumnInfo(final StructureConfigurableContext context) {
157       super("");
158       myItemComparator = (o1, o2) -> {
159         String text1 = ClasspathPanelImpl.getCellAppearance(o1, context, false).getText();
160         String text2 = ClasspathPanelImpl.getCellAppearance(o2, context, false).getText();
161         return text1.compareToIgnoreCase(text2);
162       };
163     }
164
165     @Nullable
166     @Override
167     public Comparator<ClasspathTableItem<?>> getComparator() {
168       return myItemComparator;
169     }
170
171     @Nullable
172     @Override
173     public ClasspathTableItem<?> valueOf(ClasspathTableItem<?> item) {
174       return item;
175     }
176
177     @Override
178     public Class<?> getColumnClass() {
179       return ClasspathTableItem.class;
180     }
181   }
182
183   private static @NlsContexts.ColumnName String getScopeColumnName() {
184     return JavaUiBundle.message("modules.order.export.scope.column");
185   }
186
187   static @NlsContexts.ColumnName String getExportColumnName() {
188     return JavaUiBundle.message("modules.order.export.export.column");
189   }
190 }