platform/lang-impl/src/com/intellij/execution/impl/SingleConfigurationConfigurable.java

   1 /*
   2  * Copyright 2000-2009 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
  17 package com.intellij.execution.impl;
  18
  19 import com.intellij.execution.*;
  20 import com.intellij.execution.configurations.*;
  21 import com.intellij.execution.runners.ProgramRunner;
  22 import com.intellij.openapi.diagnostic.Logger;
  23 import com.intellij.openapi.options.ConfigurationException;
  24 import com.intellij.openapi.options.SettingsEditor;
  25 import com.intellij.openapi.options.SettingsEditorConfigurable;
  26 import com.intellij.openapi.options.SettingsEditorListener;
  27 import com.intellij.openapi.util.IconLoader;
  28 import com.intellij.ui.DocumentAdapter;
  29 import org.jetbrains.annotations.NonNls;
  30
  31 import javax.swing.*;
  32 import javax.swing.event.DocumentEvent;
  33 import javax.swing.event.DocumentListener;
  34 import javax.swing.text.BadLocationException;
  35 import javax.swing.text.PlainDocument;
  36 import java.awt.*;
  37 import java.awt.event.ActionEvent;
  38 import java.awt.event.ActionListener;
  39
  40 public final class SingleConfigurationConfigurable<Config extends RunConfiguration>
  41     extends SettingsEditorConfigurable<RunnerAndConfigurationSettingsImpl> {
  42   private static final Logger LOG = Logger.getInstance("#com.intellij.execution.impl.SingleConfigurationConfigurable");
  43   private final PlainDocument myNameDocument = new PlainDocument();
  44   private ValidationResult myLastValidationResult = null;
  45   private boolean myValidationResultValid = false;
  46   private MyValidatableComponent myComponent;
  47   private final String myDisplayName;
  48   private final String myHelpTopic;
  49   private final Icon myIcon;
  50   private boolean myBrokenConfiguration;
  51
  52   private SingleConfigurationConfigurable(RunnerAndConfigurationSettingsImpl settings) {
  53     super(new ConfigurationSettingsEditorWrapper(settings), settings);
  54
  55     final Config configuration = (Config)getSettings().getConfiguration();
  56     myDisplayName = getSettings().getName();
  57     myHelpTopic = null; //TODO
  58     myIcon = configuration.getType().getIcon();
  59
  60     myBrokenConfiguration = configuration instanceof UnknownRunConfiguration;
  61
  62     setNameText(configuration.getName());
  63     myNameDocument.addDocumentListener(new DocumentAdapter() {
  64       public void textChanged(DocumentEvent event) {
  65         setModified(true);
  66       }
  67     });
  68
  69     getEditor().addSettingsEditorListener(new SettingsEditorListener() {
  70       public void stateChanged(SettingsEditor settingsEditor) {
  71         myValidationResultValid = false;
  72       }
  73     });
  74   }
  75
  76   public static <Config extends RunConfiguration> SingleConfigurationConfigurable<Config> editSettings(RunnerAndConfigurationSettingsImpl settings) {
  77     SingleConfigurationConfigurable<Config> configurable = new SingleConfigurationConfigurable<Config>(settings);
  78     configurable.reset();
  79     return configurable;
  80   }
  81
  82   public void apply() throws ConfigurationException {
  83     getSettings().setName(getNameText());
  84     super.apply();
  85   }
  86
  87   public void reset() {
  88     RunnerAndConfigurationSettings configuration = getSettings();
  89     if (configuration != null) {
  90       setNameText(configuration.getName());
  91     }
  92     super.reset();
  93   }
  94
  95   public final JComponent createComponent() {
  96     if (myComponent == null) {
  97       myComponent = new MyValidatableComponent();
  98       myComponent.myNameText.setEnabled(!myBrokenConfiguration);
  99     }
 100     return myComponent.getWholePanel();
 101   }
 102
 103   private ValidationResult getValidationResult() {
 104     if (!myValidationResultValid) {
 105       myLastValidationResult = null;
 106       try {
 107         RunnerAndConfigurationSettings snapshot = getSnapshot();
 108         if (snapshot != null) {
 109           snapshot.setName(getNameText());
 110           snapshot.checkSettings();
 111           for (ProgramRunner runner : RunnerRegistry.getInstance().getRegisteredRunners()) {
 112             for (Executor executor : ExecutorRegistry.getInstance().getRegisteredExecutors()) {
 113               if (runner.canRun(executor.getId(), snapshot.getConfiguration())) {
 114                 checkConfiguration(runner, snapshot);
 115                 break;
 116               }
 117             }
 118           }
 119         }
 120       }
 121       catch (RuntimeConfigurationException exception) {
 122         myLastValidationResult =
 123             exception != null ? new ValidationResult(exception.getLocalizedMessage(), exception.getTitle(), exception.getQuickFix()) : null;
 124       }
 125       catch (ConfigurationException e) {
 126         myLastValidationResult = new ValidationResult(e.getLocalizedMessage(), ExecutionBundle.message("invalid.data.dialog.title"), null);
 127       }
 128
 129       myValidationResultValid = true;
 130     }
 131     return myLastValidationResult;
 132   }
 133
 134   private static void checkConfiguration(final ProgramRunner runner, final RunnerAndConfigurationSettings snapshot)
 135       throws RuntimeConfigurationException {
 136     final RunnerSettings runnerSettings = snapshot.getRunnerSettings(runner);
 137     final ConfigurationPerRunnerSettings configurationSettings = snapshot.getConfigurationSettings(runner);
 138     try {
 139       runner.checkConfiguration(runnerSettings, configurationSettings);
 140     }
 141     catch (AbstractMethodError e) {
 142       //backward compatibility
 143     }
 144   }
 145
 146   public final void disposeUIResources() {
 147     super.disposeUIResources();
 148     myComponent = null;
 149   }
 150
 151   public final String getNameText() {
 152     try {
 153       return myNameDocument.getText(0, myNameDocument.getLength());
 154     }
 155     catch (BadLocationException e) {
 156       LOG.error(e);
 157       return "";
 158     }
 159   }
 160
 161   public final void addNameListner(DocumentListener listener) {
 162     myNameDocument.addDocumentListener(listener);
 163   }
 164
 165   public final void setNameText(final String name) {
 166     try {
 167       myNameDocument.replace(0, myNameDocument.getLength(), name, null);
 168     }
 169     catch (BadLocationException e) {
 170       LOG.error(e);
 171     }
 172   }
 173
 174   public final boolean isValid() {
 175     return getValidationResult() == null;
 176   }
 177
 178   public final JTextField getNameTextField() {
 179     return myComponent.myNameText;
 180   }
 181
 182   public String getDisplayName() {
 183     return myDisplayName;
 184   }
 185
 186   public Icon getIcon() {
 187     return myIcon;
 188   }
 189
 190   public String getHelpTopic() {
 191     return myHelpTopic;
 192   }
 193
 194   public Config getConfiguration() {
 195     return (Config)getSettings().getConfiguration();
 196   }
 197
 198   public RunnerAndConfigurationSettingsImpl getSnapshot() throws ConfigurationException {
 199     final SettingsEditor<RunnerAndConfigurationSettingsImpl> editor = getEditor();
 200     return editor == null ? null : editor.getSnapshot();
 201   }
 202
 203   private class MyValidatableComponent {
 204     private JLabel myNameLabel;
 205     private JTextField myNameText;
 206     private JComponent myWholePanel;
 207     private JPanel myComponentPlace;
 208     private JPanel myOutlinePanel;
 209     private JLabel myWarningLabel;
 210     private JButton myFixButton;
 211     private Runnable myQuickFix = null;
 212
 213     public MyValidatableComponent() {
 214       myNameLabel.setLabelFor(myNameText);
 215       myNameText.setDocument(myNameDocument);
 216
 217       getEditor().addSettingsEditorListener(new SettingsEditorListener() {
 218         public void stateChanged(SettingsEditor settingsEditor) {
 219           updateWarning();
 220         }
 221       });
 222
 223       myWarningLabel.setIcon(IconLoader.getIcon("/runConfigurations/configurationWarning.png"));
 224
 225       myComponentPlace.setLayout(new GridBagLayout());
 226       myComponentPlace.add(getEditorComponent(),
 227                            new GridBagConstraints(0, 0, 1, 1, 1.0, 1.0, GridBagConstraints.NORTHWEST, GridBagConstraints.BOTH,
 228                                                   new Insets(0, 0, 0, 0), 0, 0));
 229       myComponentPlace.doLayout();
 230       myFixButton.setIcon(IconLoader.getIcon("/actions/quickfixBulb.png"));
 231       updateWarning();
 232       myFixButton.addActionListener(new ActionListener() {
 233         public void actionPerformed(final ActionEvent e) {
 234           if (myQuickFix == null) {
 235             return;
 236           }
 237           myQuickFix.run();
 238           myValidationResultValid = false;
 239           updateWarning();
 240         }
 241       });
 242     }
 243
 244     public final JComponent getWholePanel() {
 245       return myWholePanel;
 246     }
 247
 248     public JComponent getEditorComponent() {
 249       return getEditor().getComponent();
 250     }
 251
 252     public ValidationResult getValidationResult() {
 253       return SingleConfigurationConfigurable.this.getValidationResult();
 254     }
 255
 256     private void updateWarning() {
 257       final ValidationResult configurationException = getValidationResult();
 258
 259       if (configurationException != null) {
 260         myOutlinePanel.setVisible(true);
 261         myWarningLabel.setVisible(true);
 262         myWarningLabel.setText(generateWarningLabelText(configurationException));
 263         final Runnable quickFix = configurationException.getQuickFix();
 264         if (quickFix == null) {
 265           myFixButton.setVisible(false);
 266         }
 267         else {
 268           myFixButton.setVisible(true);
 269           myQuickFix = quickFix;
 270         }
 271
 272       }
 273       else {
 274         myOutlinePanel.setVisible(false);
 275         myWarningLabel.setVisible(false);
 276         myFixButton.setVisible(false);
 277       }
 278     }
 279
 280     @NonNls
 281     private String generateWarningLabelText(final ValidationResult configurationException) {
 282       return "<html><body><b>" + configurationException.getTitle() + ": </b>" + configurationException.getMessage() + "</body></html>";
 283     }
 284   }
 285 }