AdtWorkspaceForm.java

/*
 * Copyright (C) 2013 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.gradle.eclipse;

import com.google.common.collect.Maps;
import com.intellij.ide.util.projectWizard.WizardContext;
import com.intellij.openapi.fileChooser.FileChooserDescriptorFactory;
import com.intellij.openapi.options.ConfigurationException;
import com.intellij.openapi.ui.TextFieldWithBrowseButton;
import com.intellij.projectImport.ProjectImportWizardStep;
import com.intellij.ui.DocumentAdapter;
import com.intellij.ui.table.JBTable;
import com.intellij.util.ui.EditableModel;

import javax.swing.*;
import javax.swing.event.DocumentEvent;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import java.awt.*;
import java.io.File;
import java.util.Arrays;
import java.util.Map;

class AdtWorkspaceForm extends ProjectImportWizardStep {
  private JBTable myPathMapTable;
  private TextFieldWithBrowseButton myWorkspaceField;
  private JPanel myPanel;
  private Map<String, File> myPathMap = Maps.newHashMap();
  private boolean myIgnore;

  AdtWorkspaceForm(WizardContext context) {
    super(context);

    myPathMapTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    myPathMapTable.setStriped(true);
    myPathMapTable.setDefaultRenderer(File.class, new DefaultTableCellRenderer() {
      @Override
      public Component getTableCellRendererComponent(JTable var1, Object var2, boolean var3, boolean var4, int var5, int var6) {
        Component component = super.getTableCellRendererComponent(var1, var2, var3, var4, var5, var6);
        File file = (File)var2;
        if (file == null || file.getPath().trim().isEmpty()) {
          super.setValue("<click to edit>");
        }
        return component;
      }
    });

    JTextField textField = new JTextField();
    DefaultCellEditor cellEditor = new DefaultCellEditor(textField);
    cellEditor.setClickCountToStart(1);
    myPathMapTable.setDefaultEditor(String.class, cellEditor);

    // TODO: Listen for invoking the button
    myWorkspaceField.addBrowseFolderListener("Select Eclipse Workspace", null, null,
                               FileChooserDescriptorFactory.createSingleFolderDescriptor());
    myWorkspaceField.getTextField().getDocument().addDocumentListener(new DocumentAdapter() {
      @Override
      protected void textChanged(DocumentEvent e) {
        File workspace = new File(myWorkspaceField.getText());
        boolean workspaceValid = GradleImport.isEclipseWorkspaceDir(workspace);
        //setBackground(myAndroidHomeLocation, workspaceValid);
        //myAndroidHomeError.setText(workspaceValid ? " " : "Please choose a valid Eclipse workspace directory.");
        if (workspaceValid) {
          AdtImportBuilder builder = AdtImportBuilder.getBuilder(getWizardContext());
          if (builder != null) {
            GradleImport importer = builder.getImporter();
            if (importer != null) {
              importer.setEclipseWorkspace(workspace);
              builder.readProjects();
              updateStep();
            }
          }
        }
      }
    });

  }


  @Override
  public JComponent getComponent() {
    return myPanel;
  }

  @Override
  public void updateStep() {
    if (myIgnore) {
      return;
    }
    super.updateStep();
    GradleImport importer = AdtImportProvider.getImporter(getWizardContext());
    if (importer != null) {
      File eclipseWorkspace = importer.getEclipseWorkspace();
      if (eclipseWorkspace != null && eclipseWorkspace.exists()) {
        try {
          myIgnore = true;
          myWorkspaceField.setText(eclipseWorkspace.getPath());
        } finally {
          myIgnore = false;
        }
      }

      Map<String,File> map = importer.getPathMap();
      for (Map.Entry<String,File> entry : map.entrySet()) {
        if (myPathMap.get(entry.getKey()) == null) {
          myPathMap.put(entry.getKey(), entry.getValue());
        }
      }
      PathMapModel model = new PathMapModel(myPathMap);
      myPathMapTable.setModel(model);
    }
  }

  @Override
  public void updateDataModel() {
    AdtImportBuilder builder = AdtImportBuilder.getBuilder(getWizardContext());
    if (builder != null) {
      GradleImport importer = builder.getImporter();
      if (importer != null) {
        File workspace = new File(myWorkspaceField.getText().trim());
        if (workspace.exists()) {
          importer.setEclipseWorkspace(workspace);
        }

        importer.getPathMap().putAll(myPathMap);
      }

      // Refresh read state in case reading the workspace paths updates the set of available warnings
      builder.readProjects();
    }
  }

  @Override
  public boolean isStepVisible() {
    GradleImport importer = AdtImportProvider.getImporter(getWizardContext());
    return importer != null && !importer.getPathMap().isEmpty();
  }

  @Override
  public boolean validate() throws ConfigurationException {
    for (Map.Entry<String,File> entry : myPathMap.entrySet()) {
      String path = entry.getKey();
      File file = entry.getValue();
      if (file == null || file.getPath().trim().isEmpty()) {
        throw new ConfigurationException("Enter a value for workspace path " + path);
      } else if (!file.exists()) {
        throw new ConfigurationException(file.getPath() + " does not exist");
      }
    }

    return super.validate();
  }

  @Override
  public String getName() {
    return "Eclipse Workspace Location";
  }

  @Override
  public JComponent getPreferredFocusedComponent() {
    return myWorkspaceField.getTextField();
  }

  private static final int WORKSPACE_PATH_COLUMN = 0;
  private static final int FILE_COLUMN = 1;

  private class PathMapModel extends AbstractTableModel implements EditableModel {
    private Map<String, File> myPathMap;
    private String[] myKeys;

    public PathMapModel(Map<String, File> map) {
      myKeys = map.keySet().toArray(new String[map.size()]);
      Arrays.sort(myKeys);
      myPathMap = map;
    }

    @Override
    public int getColumnCount() {
      return 2;
    }

    @Override
    public int getRowCount() {
      return myKeys.length;
    }

    @Override
    public Object getValueAt(int row, int col) {
      String key = myKeys[row];
      switch (col) {
        case WORKSPACE_PATH_COLUMN:
          return key;

        case FILE_COLUMN:
        default:
          return myPathMap.get(key);
      }
    }

    @Override
    public String getColumnName(int column) {
      switch (column) {
        case WORKSPACE_PATH_COLUMN:
          return "Workspace Path";
        case FILE_COLUMN:
          return "Actual Path";
        default:
          assert false : column;
          return "";
      }
    }

    @Override
    public Class<?> getColumnClass(int col) {
      switch (col) {
        case FILE_COLUMN:
          return File.class;
        case WORKSPACE_PATH_COLUMN:
        default:
          return String.class;
      }
    }

    @Override
    public boolean isCellEditable(int row, int col) {
      return col == FILE_COLUMN;
    }

    @Override
    public void setValueAt(Object aValue   , int row, int col) {
      String string = aValue == null ? "" : aValue.toString();
      myPathMap.put(myKeys[row], !string.isEmpty() ? new File(string) : null);

      AdtImportBuilder builder = AdtImportBuilder.getBuilder(getWizardContext());
      if (builder != null) {
        builder.readProjects();
      }
    }

    @Override
    public void addRow() {
      throw new UnsupportedOperationException();
    }

    @Override
    public void removeRow(int index) {
      throw new UnsupportedOperationException();
    }

    @Override
    public boolean canExchangeRows(int oldIndex, int newIndex) {
      return true;
    }

    @Override
    public void exchangeRows(int oldIndex, int newIndex) {
      String temp = myKeys[oldIndex];
      myKeys[oldIndex] = myKeys[newIndex];
      myKeys[newIndex] = temp;
    }
  }
}