Java tutorial
/* * Copyright (C) 2014 The Android Open Source Project * * 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.android.tools.idea.structure; import com.android.sdklib.AndroidTargetHash; import com.android.sdklib.AndroidVersion; import com.android.sdklib.BuildToolInfo; import com.android.sdklib.IAndroidTarget; import com.android.sdklib.repository.descriptors.PkgType; import com.android.sdklib.repository.local.LocalBuildToolPkgInfo; import com.android.sdklib.repository.local.LocalPkgInfo; import com.android.sdklib.repository.local.LocalSdk; import com.android.tools.idea.gradle.parser.BuildFileKey; import com.android.tools.idea.gradle.parser.BuildFileKeyType; import com.android.tools.idea.gradle.parser.GradleBuildFile; import com.google.common.base.Joiner; import com.google.common.base.Objects; import com.google.common.base.Splitter; import com.google.common.collect.BiMap; import com.google.common.collect.HashBiMap; import com.google.common.collect.ImmutableBiMap; import com.google.common.collect.ImmutableMap; import com.intellij.openapi.fileChooser.FileChooserDescriptor; import com.intellij.openapi.project.Project; import com.intellij.openapi.ui.ComboBox; import com.intellij.openapi.ui.TextBrowseFolderListener; import com.intellij.openapi.ui.TextFieldWithBrowseButton; import com.intellij.ui.JBColor; import com.intellij.ui.components.JBLabel; import com.intellij.ui.components.JBTextField; import com.intellij.uiDesigner.core.GridConstraints; import com.intellij.uiDesigner.core.GridLayoutManager; import org.jetbrains.android.sdk.AndroidSdkData; import org.jetbrains.android.sdk.AndroidSdkUtils; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import javax.swing.*; import javax.swing.event.DocumentEvent; import javax.swing.event.DocumentListener; import java.awt.*; import java.awt.event.ActionListener; import java.awt.event.ItemEvent; import java.awt.event.ItemListener; import java.io.File; import java.util.ArrayList; import java.util.Collection; import java.util.List; import java.util.Map; public class KeyValuePane extends JPanel implements DocumentListener, ItemListener { /** * Listener class that gets called any time the value for the given key is modified in the UI. This should be used to mark that * value is "dirty" and ensure it gets written out to the build file. */ public interface ModificationListener { void modified(@NotNull BuildFileKey key); } private final BiMap<BuildFileKey, JComponent> myProperties = HashBiMap.create(); private boolean myIsUpdating; private Map<BuildFileKey, Object> myCurrentBuildFileObject; private Map<BuildFileKey, Object> myCurrentModelObject; private final Project myProject; private final ModificationListener myListener; /** * This structure lets us define known values to populate combo boxes for some keys. The user can choose one of those known values from * the combo box, or enter a custom value. This structure is a map, where the key to the map is the BuildFileKey and the value is a * sub-map. This sub-map lets us show different strings in the combo box in the UI than what we actually read and write to the underlying * build file. For example, you can have a targetSdkVersion of 20 in the build file, but it will show that in the UI as * "API 20: Android 4.4 (KitKat Wear)". This sub-map is bi-directional, and has keys of the values that appear in the build file, and * values as what appears in the UI. For simple cases where the UI shows the same thing that appears in the build file, this can be * an identity mapping. */ private final Map<BuildFileKey, BiMap<String, String>> myKeysWithKnownValues; public KeyValuePane(@NotNull Project project, @NotNull ModificationListener listener) { myProject = project; myListener = listener; LocalSdk sdk = null; AndroidSdkData androidSdkData = AndroidSdkUtils.tryToChooseAndroidSdk(); if (androidSdkData != null) { sdk = androidSdkData.getLocalSdk(); } // Use immutable maps with builders for our built-in value maps because ImmutableBiMap ensures that iteration order is the same as // insertion order. ImmutableBiMap.Builder<String, String> buildToolsMapBuilder = ImmutableBiMap.builder(); ImmutableBiMap.Builder<String, String> apisMapBuilder = ImmutableBiMap.builder(); ImmutableBiMap.Builder<String, String> compiledApisMapBuilder = ImmutableBiMap.builder(); if (sdk != null) { LocalPkgInfo[] buildToolsPackages = sdk.getPkgsInfos(PkgType.PKG_BUILD_TOOLS); for (LocalPkgInfo buildToolsPackage : buildToolsPackages) { if (!(buildToolsPackage instanceof LocalBuildToolPkgInfo)) { continue; } BuildToolInfo buildToolInfo = ((LocalBuildToolPkgInfo) buildToolsPackage).getBuildToolInfo(); if (buildToolInfo == null) { continue; } String buildToolVersion = buildToolInfo.getRevision().toString(); buildToolsMapBuilder.put(buildToolVersion, buildToolVersion); } for (IAndroidTarget target : sdk.getTargets()) { if (target.isPlatform()) { AndroidVersion version = target.getVersion(); String codename = version.getCodename(); String apiString, platformString; if (codename != null) { apiString = codename; platformString = AndroidTargetHash.getPlatformHashString(version); } else { platformString = apiString = Integer.toString(version.getApiLevel()); } String label = AndroidSdkUtils.getTargetLabel(target); apisMapBuilder.put(apiString, label); compiledApisMapBuilder.put(platformString, label); } } } BiMap<String, String> installedBuildTools = buildToolsMapBuilder.build(); BiMap<String, String> installedApis = apisMapBuilder.build(); BiMap<String, String> installedCompileApis = compiledApisMapBuilder.build(); BiMap<String, String> javaCompatibility = ImmutableBiMap.of("JavaVersion.VERSION_1_6", "1.6", "JavaVersion.VERSION_1_7", "1.7"); myKeysWithKnownValues = ImmutableMap.<BuildFileKey, BiMap<String, String>>builder() .put(BuildFileKey.MIN_SDK_VERSION, installedApis) .put(BuildFileKey.TARGET_SDK_VERSION, installedApis) .put(BuildFileKey.COMPILE_SDK_VERSION, installedCompileApis) .put(BuildFileKey.BUILD_TOOLS_VERSION, installedBuildTools) .put(BuildFileKey.SOURCE_COMPATIBILITY, javaCompatibility) .put(BuildFileKey.TARGET_COMPATIBILITY, javaCompatibility).build(); } /** * Sets the current object as seen by parsing the build file directly. This controls what the user explicitly sets through the build file. * Any keys that are set to null are unset in the build file and will take on default values when the build file is executed. */ public void setCurrentBuildFileObject(@Nullable Map<BuildFileKey, Object> currentBuildFileObject) { myCurrentBuildFileObject = currentBuildFileObject; } /** * Sets the current object as seen by querying the Gradle model after the build file is evaluated. This shows the user what the build file * will actually do, showing the default values of keys (as supplied by the plugin) that are otherwise not explicitly set in the file. */ public void setCurrentModelObject(@Nullable Map<BuildFileKey, Object> currentModelObject) { myCurrentModelObject = currentModelObject; } public void init(GradleBuildFile gradleBuildFile, Collection<BuildFileKey> properties) { GridLayoutManager layout = new GridLayoutManager(properties.size() + 1, 2); setLayout(layout); GridConstraints constraints = new GridConstraints(); constraints.setAnchor(GridConstraints.ANCHOR_WEST); constraints.setVSizePolicy(GridConstraints.SIZEPOLICY_FIXED); for (BuildFileKey property : properties) { constraints.setColumn(0); constraints.setFill(GridConstraints.FILL_NONE); constraints.setHSizePolicy(GridConstraints.SIZEPOLICY_FIXED); add(new JBLabel(property.getDisplayName()), constraints); constraints.setColumn(1); constraints.setFill(GridConstraints.FILL_HORIZONTAL); constraints.setHSizePolicy(GridConstraints.SIZEPOLICY_WANT_GROW); JComponent component; switch (property.getType()) { case BOOLEAN: { constraints.setFill(GridConstraints.FILL_NONE); ComboBox comboBox = getComboBox(false); comboBox.addItem(""); comboBox.addItem("true"); comboBox.addItem("false"); comboBox.setPrototypeDisplayValue("(false) "); component = comboBox; break; } case FILE: case FILE_AS_STRING: { JBTextField textField = new JBTextField(); TextFieldWithBrowseButton fileField = new TextFieldWithBrowseButton(textField); FileChooserDescriptor d = new FileChooserDescriptor(true, false, false, true, false, false); d.setShowFileSystemRoots(true); fileField.addBrowseFolderListener(new TextBrowseFolderListener(d)); fileField.getTextField().getDocument().addDocumentListener(this); component = fileField; break; } case REFERENCE: { constraints.setFill(GridConstraints.FILL_NONE); ComboBox comboBox = getComboBox(true); if (hasKnownValues(property)) { for (String s : myKeysWithKnownValues.get(property).values()) { comboBox.addItem(s); } } // If there are no hardcoded values, the combo box's values will get populated later when the panel for the container reference // type wakes up and notifies us of its current values. component = comboBox; break; } case CLOSURE: case STRING: case INTEGER: default: { if (hasKnownValues(property)) { constraints.setFill(GridConstraints.FILL_NONE); ComboBox comboBox = getComboBox(true); for (String s : myKeysWithKnownValues.get(property).values()) { comboBox.addItem(s); } component = comboBox; } else { JBTextField textField = new JBTextField(); textField.getDocument().addDocumentListener(this); component = textField; } break; } } add(component, constraints); myProperties.put(property, component); constraints.setRow(constraints.getRow() + 1); } constraints.setColumn(0); constraints.setVSizePolicy(GridConstraints.FILL_VERTICAL); constraints.setHSizePolicy(GridConstraints.SIZEPOLICY_FIXED); add(new JBLabel(""), constraints); updateUiFromCurrentObject(); } public void updateReferenceValues(@NotNull BuildFileKey containerProperty, @NotNull Iterable<String> values) { BuildFileKey itemType = containerProperty.getItemType(); if (itemType == null) { return; } ComboBox comboBox = (ComboBox) myProperties.get(itemType); if (comboBox == null) { return; } myIsUpdating = true; try { String currentValue = comboBox.getEditor().getItem().toString(); comboBox.removeAllItems(); for (String value : values) { comboBox.addItem(value); } comboBox.setSelectedItem(currentValue); } finally { myIsUpdating = false; } } private ComboBox getComboBox(boolean editable) { ComboBox comboBox = new ComboBox(); comboBox.addItemListener(this); comboBox.setEditor(new ComboBoxEditor() { private final JBTextField myTextField = new JBTextField(); @Override public Component getEditorComponent() { return myTextField; } @Override public void setItem(Object o) { myTextField.setText(o != null ? o.toString() : ""); } @Override public Object getItem() { return myTextField.getText(); } @Override public void selectAll() { myTextField.selectAll(); } @Override public void addActionListener(ActionListener actionListener) { } @Override public void removeActionListener(ActionListener actionListener) { } }); comboBox.setEditable(true); JBTextField editorComponent = (JBTextField) comboBox.getEditor().getEditorComponent(); editorComponent.setEditable(editable); editorComponent.getDocument().addDocumentListener(this); return comboBox; } /** * Reads the state of the UI form objects and writes them into the currently selected object in the list, setting the dirty bit as * appropriate. */ private void updateCurrentObjectFromUi() { if (myIsUpdating || myCurrentBuildFileObject == null) { return; } for (Map.Entry<BuildFileKey, JComponent> entry : myProperties.entrySet()) { BuildFileKey key = entry.getKey(); JComponent component = entry.getValue(); Object currentValue = myCurrentBuildFileObject.get(key); Object newValue; BuildFileKeyType type = key.getType(); switch (type) { case BOOLEAN: { ComboBox comboBox = (ComboBox) component; JBTextField editorComponent = (JBTextField) comboBox.getEditor().getEditorComponent(); int index = comboBox.getSelectedIndex(); if (index == 2) { newValue = Boolean.FALSE; editorComponent.setForeground(JBColor.BLACK); } else if (index == 1) { newValue = Boolean.TRUE; editorComponent.setForeground(JBColor.BLACK); } else { newValue = null; editorComponent.setForeground(JBColor.GRAY); } break; } case FILE: case FILE_AS_STRING: { newValue = ((TextFieldWithBrowseButton) component).getText(); if ("".equals(newValue)) { newValue = null; } if (newValue != null) { newValue = new File(newValue.toString()); } break; } case INTEGER: { try { if (hasKnownValues(key)) { String newStringValue = ((ComboBox) component).getEditor().getItem().toString(); newStringValue = getMappedValue(myKeysWithKnownValues.get(key).inverse(), newStringValue); newValue = Integer.valueOf(newStringValue); } else { newValue = Integer.valueOf(((JBTextField) component).getText()); } } catch (Exception e) { newValue = null; } break; } case REFERENCE: { newValue = ((ComboBox) component).getEditor().getItem(); String newStringValue = (String) newValue; if (hasKnownValues(key)) { newStringValue = getMappedValue(myKeysWithKnownValues.get(key).inverse(), newStringValue); } if (newStringValue != null && newStringValue.isEmpty()) { newStringValue = null; } String prefix = getReferencePrefix(key); if (newStringValue != null && !newStringValue.startsWith(prefix)) { newStringValue = prefix + newStringValue; } newValue = newStringValue; break; } case CLOSURE: case STRING: default: { if (hasKnownValues(key)) { String newStringValue = ((ComboBox) component).getEditor().getItem().toString(); newStringValue = getMappedValue(myKeysWithKnownValues.get(key).inverse(), newStringValue); if (newStringValue.isEmpty()) { newStringValue = null; } newValue = newStringValue; } else { newValue = ((JBTextField) component).getText(); if ("".equals(newValue)) { newValue = null; } } if (type == BuildFileKeyType.CLOSURE && newValue != null) { List newListValue = new ArrayList(); for (String s : Splitter.on(',').omitEmptyStrings().trimResults().split((String) newValue)) { newListValue.add(key.getValueFactory().parse(s, myProject)); } newValue = newListValue; } break; } } if (!Objects.equal(currentValue, newValue)) { if (newValue == null) { myCurrentBuildFileObject.remove(key); } else { myCurrentBuildFileObject.put(key, newValue); } if (GradleBuildFile.shouldWriteValue(currentValue, newValue)) { myListener.modified(key); } } } } /** * Updates the form UI objects to reflect the currently selected object. Clears the objects and disables them if there is no selected * object. */ public void updateUiFromCurrentObject() { myIsUpdating = true; for (Map.Entry<BuildFileKey, JComponent> entry : myProperties.entrySet()) { BuildFileKey key = entry.getKey(); JComponent component = entry.getValue(); Object value = myCurrentBuildFileObject != null ? myCurrentBuildFileObject.get(key) : null; final Object modelValue = myCurrentModelObject != null ? myCurrentModelObject.get(key) : null; switch (key.getType()) { case BOOLEAN: { ComboBox comboBox = (ComboBox) component; String text = formatDefaultValue(modelValue); comboBox.removeItemAt(0); comboBox.insertItemAt(text, 0); JBTextField editorComponent = (JBTextField) comboBox.getEditor().getEditorComponent(); if (Boolean.FALSE.equals(value)) { comboBox.setSelectedIndex(2); editorComponent.setForeground(JBColor.BLACK); } else if (Boolean.TRUE.equals(value)) { comboBox.setSelectedIndex(1); editorComponent.setForeground(JBColor.BLACK); } else { comboBox.setSelectedIndex(0); editorComponent.setForeground(JBColor.GRAY); } break; } case FILE: case FILE_AS_STRING: { TextFieldWithBrowseButton fieldWithButton = (TextFieldWithBrowseButton) component; fieldWithButton.setText(value != null ? value.toString() : ""); JBTextField textField = (JBTextField) fieldWithButton.getTextField(); textField.getEmptyText().setText(formatDefaultValue(modelValue)); break; } case REFERENCE: { String stringValue = (String) value; if (hasKnownValues(key) && stringValue != null) { stringValue = getMappedValue(myKeysWithKnownValues.get(key), stringValue); } String prefix = getReferencePrefix(key); if (stringValue == null) { stringValue = ""; } else if (stringValue.startsWith(prefix)) { stringValue = stringValue.substring(prefix.length()); } ComboBox comboBox = (ComboBox) component; JBTextField textField = (JBTextField) comboBox.getEditor().getEditorComponent(); textField.getEmptyText().setText(formatDefaultValue(modelValue)); comboBox.setSelectedItem(stringValue); break; } case CLOSURE: if (value instanceof List) { value = Joiner.on(", ").join((List) value); } // Fall through to INTEGER/STRING/default case case INTEGER: case STRING: default: { if (hasKnownValues(key)) { if (value != null) { value = getMappedValue(myKeysWithKnownValues.get(key), value.toString()); } ComboBox comboBox = (ComboBox) component; comboBox.setSelectedItem(value != null ? value.toString() : ""); JBTextField textField = (JBTextField) comboBox.getEditor().getEditorComponent(); textField.getEmptyText().setText(formatDefaultValue(modelValue)); } else { JBTextField textField = (JBTextField) component; textField.setText(value != null ? value.toString() : ""); textField.getEmptyText().setText(formatDefaultValue(modelValue)); } break; } } component.setEnabled(myCurrentBuildFileObject != null); } myIsUpdating = false; } @NotNull private static String formatDefaultValue(@Nullable Object modelValue) { if (modelValue == null) { return ""; } String s = modelValue.toString(); return !s.isEmpty() ? "(" + s + ")" : ""; } @NotNull private static String getMappedValue(@NotNull BiMap<String, String> map, @NotNull String value) { if (map.containsKey(value)) { value = map.get(value); } return value; } private boolean hasKnownValues(BuildFileKey key) { return myKeysWithKnownValues.containsKey(key); } @Override public void insertUpdate(@NotNull DocumentEvent documentEvent) { updateCurrentObjectFromUi(); } @Override public void removeUpdate(@NotNull DocumentEvent documentEvent) { updateCurrentObjectFromUi(); } @Override public void changedUpdate(@NotNull DocumentEvent documentEvent) { updateCurrentObjectFromUi(); } @Override public void itemStateChanged(ItemEvent event) { if (event.getStateChange() == ItemEvent.SELECTED) { updateCurrentObjectFromUi(); } } @NotNull private static String getReferencePrefix(@NotNull BuildFileKey key) { BuildFileKey containerType = key.getContainerType(); if (containerType != null) { String path = containerType.getPath(); String lastLeaf = path.substring(path.lastIndexOf('/') + 1); return lastLeaf + "."; } else { return ""; } } }