private static String getStatusMessage(final CvsHandler handler) {
final String actionName = handler.getTitle();
if (handler.getErrors().isEmpty()) {
return CvsBundle.message("status.text.action.completed", actionName);
} else {
return CvsBundle.message("status.text.action.completed.with.errors", actionName);
}
}
public ErrorTreeView getErrorsTreeView() {
if (myErrorsView == null) {
myErrorsView =
ErrorViewFactory.SERVICE
.getInstance()
.createErrorTreeView(
myProject,
null,
true,
new AnAction[] {
(DefaultActionGroup) ActionManager.getInstance().getAction("CvsActions")
},
new AnAction[] {new GlobalCvsSettingsAction(), new ReconfigureCvsRootAction()},
new ContentManagerProvider() {
public ContentManager getParentContent() {
return getContentManager();
}
});
addTab(
CvsBundle.message("tab.title.errors"),
myErrorsView.getComponent(),
true,
false,
true,
false,
null,
"cvs.errors");
}
return myErrorsView;
}
public MyCopyAction() {
super(CvsBundle.message("action.name.copy"), null, IconLoader.getIcon("/general/copy.png"));
registerCustomShortcutSet(
new CustomShortcutSet(
KeyStroke.getKeyStroke(
KeyEvent.VK_C, SystemInfo.isMac ? KeyEvent.META_MASK : KeyEvent.CTRL_MASK)),
myList);
}
protected Action[] createLeftSideActions() {
AbstractAction globalSettingsAction =
new AbstractAction(CvsBundle.message("button.text.global.settings")) {
public void actionPerformed(ActionEvent e) {
new ConfigureCvsGlobalSettingsDialog().show();
}
};
return new Action[] {globalSettingsAction};
}
public CvsConfigurationsListEditor(List<CvsRootConfiguration> configs, Project project) {
super(true);
myCvs2SettingsEditPanel = new Cvs2SettingsEditPanel(project);
setTitle(CvsBundle.message("operation.name.edit.configurations"));
myList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
selectNone();
fillModel(configs);
myCvs2SettingsEditPanel.addCvsRootChangeListener(
new CvsRootChangeListener() {
public void onCvsRootChanged() {
if (mySelection == null) return;
myCvs2SettingsEditPanel.saveTo(mySelection, false);
myList.repaint();
}
});
setTitle(CvsBundle.message("dialog.title.cvs.roots"));
if (!configs.isEmpty()) {
myList.setSelectedIndex(0);
}
init();
}
public Editor addOutput(Editor output) {
LOG.assertTrue(myOutput == null);
if (myOutput == null) {
addTab(
CvsBundle.message("tab.title.cvs.output"),
output.getComponent(),
false,
false,
false,
true,
null,
"cvs.cvsOutput");
myOutput = output;
}
return myOutput;
}
public Settings createConfiguration(String rootAsString, boolean check) {
final CvsRootParser root = CvsRootParser.valueOf(rootAsString, check);
final Settings result = myBuilder.createSettings(root.METHOD, rootAsString);
if (CvsMethod.LOCAL_METHOD.equals(root.METHOD)) {
fillLocalSettings(root.REPOSITORY, result);
} else if (CvsMethod.PSERVER_METHOD.equals(root.METHOD)) {
fillPServerSettings(root, result, rootAsString);
} else if (CvsMethod.EXT_METHOD.equals(root.METHOD)) {
fillSettings(root, result);
} else if (CvsMethod.SSH_METHOD.equals(root.METHOD)) {
fillSettings(root, result);
} else {
throw new CvsRootException(
CvsBundle.message("exception.text.unsupported.method", root.METHOD, rootAsString));
}
return result;
}
public ReconfigureCvsRootAction() {
super(CvsBundle.message("action.name.reconfigure.cvs.root"), null, AllIcons.Nodes.Cvs_roots);
}
public GlobalCvsSettingsAction() {
super(
CvsBundle.message("configure.global.cvs.settings.action.name"),
null,
AllIcons.Nodes.Cvs_global);
}
/** author: lesya */
public class KeywordSubstitutionWrapper {
private final KeywordSubstitution myKeywordSubstitution;
private final String myDisplayName;
public static final KeywordSubstitutionWrapper BINARY =
new KeywordSubstitutionWrapper(
KeywordSubstitution.BINARY,
com.intellij.CvsBundle.message("keyword.substitution.binary"));
public static final KeywordSubstitutionWrapper KEYWORD_COMPRESSION =
new KeywordSubstitutionWrapper(
KeywordSubstitution.KEYWORD_COMPRESSION,
com.intellij.CvsBundle.message("keyword.substitution.compression"));
public static final KeywordSubstitutionWrapper KEYWORD_EXPANSION =
new KeywordSubstitutionWrapper(
KeywordSubstitution.KEYWORD_EXPANSION,
com.intellij.CvsBundle.message("keyword.substitution.expansion"));
public static final KeywordSubstitutionWrapper KEYWORD_EXPANSION_LOCKER =
new KeywordSubstitutionWrapper(
KeywordSubstitution.KEYWORD_EXPANSION_LOCKER,
com.intellij.CvsBundle.message("keyword.substitution.expansion.locker"));
public static final KeywordSubstitutionWrapper NO_SUBSTITUTION =
new KeywordSubstitutionWrapper(
KeywordSubstitution.NO_SUBSTITUTION,
com.intellij.CvsBundle.message("keyword.substitution.no.substitution"));
public static final KeywordSubstitutionWrapper KEYWORD_REPLACEMENT =
new KeywordSubstitutionWrapper(
KeywordSubstitution.KEYWORD_REPLACEMENT,
com.intellij.CvsBundle.message("keyword.substitution.replacement"));
private KeywordSubstitutionWrapper(KeywordSubstitution keywordSubstitution, String displayName) {
myKeywordSubstitution = keywordSubstitution;
myDisplayName = displayName;
}
public KeywordSubstitution getSubstitution() {
return myKeywordSubstitution;
}
public String toString() {
return myDisplayName;
}
public static KeywordSubstitutionWrapper getValue(String substitution) {
KeywordSubstitution keywordSubstitution = KeywordSubstitution.getValue(substitution);
return getValue(keywordSubstitution);
}
public static KeywordSubstitutionWrapper getValue(KeywordSubstitution substitution) {
if (substitution == KeywordSubstitution.BINARY) return KeywordSubstitutionWrapper.BINARY;
if (substitution == KeywordSubstitution.KEYWORD_COMPRESSION)
return KeywordSubstitutionWrapper.KEYWORD_COMPRESSION;
if (substitution == KeywordSubstitution.KEYWORD_EXPANSION)
return KeywordSubstitutionWrapper.KEYWORD_EXPANSION;
if (substitution == KeywordSubstitution.KEYWORD_EXPANSION_LOCKER)
return KeywordSubstitutionWrapper.KEYWORD_EXPANSION_LOCKER;
if (substitution == KeywordSubstitution.NO_SUBSTITUTION)
return KeywordSubstitutionWrapper.NO_SUBSTITUTION;
if (substitution == KeywordSubstitution.KEYWORD_REPLACEMENT)
return KeywordSubstitutionWrapper.KEYWORD_REPLACEMENT;
return null;
}
public String getStringRepresentation() {
if (myKeywordSubstitution == null) return null;
return myKeywordSubstitution.toString();
}
}
public MyRemoveAction() {
super(
CvsBundle.message("action.name.remove"), null, IconLoader.getIcon("/general/remove.png"));
registerCustomShortcutSet(CommonShortcuts.DELETE, myList);
}
public MyAddAction() {
super(CvsBundle.message("action.name.add"), null, IconLoader.getIcon("/general/add.png"));
registerCustomShortcutSet(CommonShortcuts.INSERT, myList);
}
/** author: lesya, Bas Leijdekkers */
public class CustomizeKeywordSubstitutionDialog extends DialogWrapper {
private static final DefaultCellEditor EDITOR =
new DefaultCellEditor(new JComboBox(KeywordSubstitutionWrapper.values().toArray()));
private static final DefaultTableCellRenderer RENDERER = new DefaultTableCellRenderer();
private static final ColumnInfo KEYWORD_SUBSTITUTION =
new ColumnInfo<FileExtension, KeywordSubstitutionWrapper>(
CvsBundle.message("import.wizard.keyword.substitution.column.name")) {
@Override
public KeywordSubstitutionWrapper valueOf(FileExtension extension) {
return extension.getKeywordSubstitution();
}
@Override
public Comparator<FileExtension> getComparator() {
return new Comparator<FileExtension>() {
@Override
public int compare(FileExtension extension1, FileExtension extension2) {
final KeywordSubstitutionWrapper firstSubstitution =
extension1.getKeywordSubstitutionsWithSelection().getSelection();
final KeywordSubstitutionWrapper secondSubstitution =
extension2.getKeywordSubstitutionsWithSelection().getSelection();
return firstSubstitution.toString().compareTo(secondSubstitution.toString());
}
};
}
@Override
public boolean isCellEditable(FileExtension extension) {
return true;
}
@Override
public void setValue(FileExtension extension, KeywordSubstitutionWrapper aValue) {
extension.setKeywordSubstitution(aValue);
}
@Override
public TableCellRenderer getRenderer(FileExtension extension) {
return RENDERER;
}
@Override
public TableCellEditor getEditor(FileExtension extension) {
return EDITOR;
}
@Override
public int getAdditionalWidth() {
return 20;
}
@Override
public String getMaxStringValue(JTable table) {
return KeywordSubstitutionWrapper.KEYWORD_EXPANSION_LOCKER.toString();
}
};
private static final ColumnInfo EXTENSION_COLUMN =
new ColumnInfo<FileExtension, String>(
CvsBundle.message("import.wizard.file.extension.column.name")) {
@Override
public String valueOf(FileExtension o) {
return o.getExtension();
}
@Override
public Comparator<FileExtension> getComparator() {
return new Comparator<FileExtension>() {
@Override
public int compare(FileExtension extension1, FileExtension extension2) {
return extension1.getExtension().compareTo(extension2.getExtension());
}
};
}
@Override
public int getAdditionalWidth() {
return 50;
}
@Override
public String getMaxStringValue(JTable table) {
return getName();
}
};
private static final ColumnInfo[] COLUMNS =
new ColumnInfo[] {EXTENSION_COLUMN, KEYWORD_SUBSTITUTION};
private final ListTableModel<FileExtension> myModel;
private final ImportConfiguration myImportConfiguration;
public CustomizeKeywordSubstitutionDialog(
Project project, String description, ImportConfiguration importConfiguration) {
super(project);
setTitle(description);
myImportConfiguration = importConfiguration;
myModel = new ListTableModel<FileExtension>(COLUMNS);
myModel.setItems(collectFileTypes());
init();
pack();
}
private List<FileExtension> collectFileTypes() {
final Collection<FileExtension> storedExtensions = myImportConfiguration.getExtensions();
final ArrayList<FileExtension> result = new ArrayList<FileExtension>();
result.addAll(storedExtensions);
final FileType[] fileTypes = FileTypeManager.getInstance().getRegisteredFileTypes();
for (FileType fileType : fileTypes) {
final String[] extensions = FileTypeManager.getInstance().getAssociatedExtensions(fileType);
for (String extension : extensions) {
final FileExtension fileExtension = new FileExtension(extension);
if (!result.contains(fileExtension)) result.add(fileExtension);
}
}
return result;
}
@Override
protected void doOKAction() {
myImportConfiguration.setExtensions(myModel.getItems());
super.doOKAction();
}
@Override
protected JComponent createCenterPanel() {
final TableView<FileExtension> table = new TableView<FileExtension>(myModel);
final Dimension preferredSize = table.getPreferredSize();
final JScrollPane scrollPane = ScrollPaneFactory.createScrollPane(table);
final Dimension scrollPaneSize = scrollPane.getPreferredSize();
scrollPaneSize.width = preferredSize.width;
scrollPane.setPreferredSize(scrollPaneSize);
return scrollPane;
}
public List<FileExtension> getFileExtensions() {
return myModel.getItems();
}
}