platform/platform-impl/src/com/intellij/util/ui/SwingHelper.java

   1 /*
   2  * Copyright 2000-2014 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.util.ui;
  17
  18 import com.intellij.ide.BrowserUtil;
  19 import com.intellij.openapi.actionSystem.ActionManager;
  20 import com.intellij.openapi.actionSystem.AnAction;
  21 import com.intellij.openapi.actionSystem.AnActionEvent;
  22 import com.intellij.openapi.actionSystem.DefaultActionGroup;
  23 import com.intellij.openapi.diagnostic.Logger;
  24 import com.intellij.openapi.fileChooser.FileChooserDescriptor;
  25 import com.intellij.openapi.fileChooser.FileChooserFactory;
  26 import com.intellij.openapi.ide.CopyPasteManager;
  27 import com.intellij.openapi.project.Project;
  28 import com.intellij.openapi.ui.*;
  29 import com.intellij.openapi.util.SystemInfo;
  30 import com.intellij.openapi.util.text.StringUtil;
  31 import com.intellij.ui.HyperlinkLabel;
  32 import com.intellij.ui.TextFieldWithHistory;
  33 import com.intellij.ui.TextFieldWithHistoryWithBrowseButton;
  34 import com.intellij.util.NotNullProducer;
  35 import com.intellij.util.PlatformIcons;
  36 import com.intellij.util.containers.ComparatorUtil;
  37 import com.intellij.util.containers.ContainerUtil;
  38 import org.jetbrains.annotations.NotNull;
  39 import org.jetbrains.annotations.Nullable;
  40
  41 import javax.swing.*;
  42 import javax.swing.event.PopupMenuEvent;
  43 import javax.swing.event.PopupMenuListener;
  44 import javax.swing.table.DefaultTableCellRenderer;
  45 import javax.swing.table.TableCellRenderer;
  46 import javax.swing.table.TableColumn;
  47 import java.awt.*;
  48 import java.awt.datatransfer.StringSelection;
  49 import java.awt.datatransfer.Transferable;
  50 import java.awt.event.ActionListener;
  51 import java.util.Collection;
  52 import java.util.List;
  53 import java.util.Set;
  54
  55 public class SwingHelper {
  56
  57   private static final Logger LOG = Logger.getInstance(SwingHelper.class);
  58
  59   /**
  60    * Creates panel whose content consists of given {@code children} components
  61    * stacked vertically each on another in a given order.
  62    *
  63    * @param childAlignmentX Component.LEFT_ALIGNMENT, Component.CENTER_ALIGNMENT or Component.RIGHT_ALIGNMENT
  64    * @param children        children components
  65    * @return created panel
  66    */
  67   @NotNull
  68   public static JPanel newVerticalPanel(float childAlignmentX, Component... children) {
  69     return newGenericBoxPanel(true, childAlignmentX, children);
  70   }
  71
  72   @NotNull
  73   public static JPanel newLeftAlignedVerticalPanel(Component... children) {
  74     return newVerticalPanel(Component.LEFT_ALIGNMENT, children);
  75   }
  76
  77   @NotNull
  78   public static JPanel newLeftAlignedVerticalPanel(@NotNull Collection<Component> children) {
  79     return newVerticalPanel(Component.LEFT_ALIGNMENT, children);
  80   }
  81
  82   @NotNull
  83   public static JPanel newVerticalPanel(float childAlignmentX, @NotNull Collection<Component> children) {
  84     return newVerticalPanel(childAlignmentX, children.toArray(new Component[children.size()]));
  85   }
  86
  87   /**
  88    * Creates panel whose content consists of given {@code children} components horizontally
  89    * stacked each on another in a given order.
  90    *
  91    * @param childAlignmentY Component.TOP_ALIGNMENT, Component.CENTER_ALIGNMENT or Component.BOTTOM_ALIGNMENT
  92    * @param children        children components
  93    * @return created panel
  94    */
  95   @NotNull
  96   public static JPanel newHorizontalPanel(float childAlignmentY, Component... children) {
  97     return newGenericBoxPanel(false, childAlignmentY, children);
  98   }
  99
 100   @NotNull
 101   public static JPanel newHorizontalPanel(float childAlignmentY, @NotNull Collection<Component> children) {
 102     return newHorizontalPanel(childAlignmentY, children.toArray(new Component[children.size()]));
 103   }
 104
 105   private static JPanel newGenericBoxPanel(boolean verticalOrientation,
 106                                            float childAlignment,
 107                                            Component... children) {
 108     JPanel panel = new JPanel();
 109     int axis = verticalOrientation ? BoxLayout.Y_AXIS : BoxLayout.X_AXIS;
 110     panel.setLayout(new BoxLayout(panel, axis));
 111     for (Component child : children) {
 112       panel.add(child, childAlignment);
 113       if (child instanceof JComponent) {
 114         JComponent jChild = (JComponent)child;
 115         if (verticalOrientation) {
 116           jChild.setAlignmentX(childAlignment);
 117         }
 118         else {
 119           jChild.setAlignmentY(childAlignment);
 120         }
 121       }
 122     }
 123     return panel;
 124   }
 125
 126   @NotNull
 127   public static JPanel wrapWithoutStretch(@NotNull JComponent component) {
 128     JPanel panel = new JPanel(new FlowLayout(FlowLayout.LEFT, 0, 0));
 129     panel.add(component);
 130     return panel;
 131   }
 132
 133   @NotNull
 134   public static JPanel wrapWithHorizontalStretch(@NotNull JComponent component) {
 135     JPanel panel = new JPanel(new BorderLayout(0, 0));
 136     panel.add(component, BorderLayout.NORTH);
 137     return panel;
 138   }
 139
 140   public static void setPreferredWidthToFitText(@NotNull TextFieldWithHistoryWithBrowseButton component) {
 141     int childWidth = calcWidthToFitText(component.getChildComponent().getTextEditor(), 35);
 142     setPreferredWidthForComponentWithBrowseButton(component, childWidth);
 143   }
 144
 145   public static void setPreferredWidthToFitText(@NotNull TextFieldWithBrowseButton component) {
 146     int childWidth = calcWidthToFitText(component.getChildComponent(), 20);
 147     setPreferredWidthForComponentWithBrowseButton(component, childWidth);
 148   }
 149
 150   private static <T extends JComponent> void setPreferredWidthForComponentWithBrowseButton(@NotNull ComponentWithBrowseButton<T> component,
 151                                                                                            int childPrefWidth) {
 152     Dimension buttonPrefSize = component.getButton().getPreferredSize();
 153     setPreferredWidth(component, childPrefWidth + buttonPrefSize.width);
 154   }
 155
 156   public static void setPreferredWidthToFitText(@NotNull JTextField textField) {
 157     setPreferredWidthToFitText(textField, 15);
 158   }
 159
 160   public static void setPreferredWidthToFitText(@NotNull JTextField textField, int additionalWidth) {
 161     setPreferredSizeToFitText(textField, StringUtil.notNullize(textField.getText()), additionalWidth);
 162   }
 163
 164   public static void setPreferredWidthToFitText(@NotNull JTextField textField, @NotNull String text) {
 165     setPreferredSizeToFitText(textField, text, 15);
 166   }
 167
 168   private static void setPreferredSizeToFitText(@NotNull JTextField textField, @NotNull String text, int additionalWidth) {
 169     int width = calcWidthToFitText(textField, text, additionalWidth);
 170     setPreferredWidth(textField, width);
 171   }
 172
 173   private static int calcWidthToFitText(@NotNull JTextField textField, int additionalWidth) {
 174     return calcWidthToFitText(textField, textField.getText(), additionalWidth);
 175   }
 176
 177   private static int calcWidthToFitText(@NotNull JTextField textField, @NotNull String text, int additionalWidth) {
 178     return textField.getFontMetrics(textField.getFont()).stringWidth(text) + additionalWidth;
 179   }
 180
 181   public static void adjustDialogSizeToFitPreferredSize(@NotNull DialogWrapper dialogWrapper) {
 182     JRootPane rootPane = dialogWrapper.getRootPane();
 183     Dimension componentSize = rootPane.getSize();
 184     Dimension componentPreferredSize = rootPane.getPreferredSize();
 185     if (componentPreferredSize.width <= componentSize.width && componentPreferredSize.height <= componentSize.height) {
 186       return;
 187     }
 188     int dw = Math.max(0, componentPreferredSize.width - componentSize.width);
 189     int dh = Math.max(0, componentPreferredSize.height - componentSize.height);
 190
 191     Dimension oldDialogSize = dialogWrapper.getSize();
 192     Dimension newDialogSize = new Dimension(oldDialogSize.width + dw, oldDialogSize.height + dh);
 193
 194     dialogWrapper.setSize(newDialogSize.width, newDialogSize.height);
 195     rootPane.revalidate();
 196     rootPane.repaint();
 197
 198     LOG.info("DialogWrapper '" + dialogWrapper.getTitle() + "' has been re-sized (added width: " + dw + ", added height: " + dh + ")");
 199   }
 200
 201   public static <T> void updateItems(@NotNull JComboBox comboBox,
 202                                      @NotNull List<T> newItems,
 203                                      @Nullable T newSelectedItemIfSelectionCannotBePreserved) {
 204     if (!shouldUpdate(comboBox, newItems)) {
 205       return;
 206     }
 207     Object selectedItem = comboBox.getSelectedItem();
 208     //noinspection SuspiciousMethodCalls
 209     if (selectedItem != null && !newItems.contains(selectedItem)) {
 210       selectedItem = null;
 211     }
 212     if (selectedItem == null && newItems.contains(newSelectedItemIfSelectionCannotBePreserved)) {
 213       selectedItem = newSelectedItemIfSelectionCannotBePreserved;
 214     }
 215     comboBox.removeAllItems();
 216     for (T newItem : newItems) {
 217       comboBox.addItem(newItem);
 218     }
 219     if (selectedItem != null) {
 220       int count = comboBox.getItemCount();
 221       for (int i = 0; i < count; i++) {
 222         Object item = comboBox.getItemAt(i);
 223         if (selectedItem.equals(item)) {
 224           comboBox.setSelectedIndex(i);
 225           break;
 226         }
 227       }
 228     }
 229   }
 230
 231   private static <T> boolean shouldUpdate(@NotNull JComboBox comboBox, @NotNull List<T> newItems) {
 232     int count = comboBox.getItemCount();
 233     if (newItems.size() != count) {
 234       return true;
 235     }
 236     for (int i = 0; i < count; i++) {
 237       Object oldItem = comboBox.getItemAt(i);
 238       T newItem = newItems.get(i);
 239       if (!ComparatorUtil.equalsNullable(oldItem, newItem)) {
 240         return true;
 241       }
 242     }
 243     return false;
 244   }
 245
 246   public static void setNoBorderCellRendererFor(@NotNull TableColumn column) {
 247     final TableCellRenderer previous = column.getCellRenderer();
 248     column.setCellRenderer(new DefaultTableCellRenderer() {
 249       @Override
 250       public Component getTableCellRendererComponent(JTable table,
 251                                                      Object value,
 252                                                      boolean isSelected,
 253                                                      boolean hasFocus,
 254                                                      int row,
 255                                                      int column) {
 256         Component component;
 257         if (previous != null) {
 258           component = previous.getTableCellRendererComponent(table, value, isSelected, false, row, column);
 259         }
 260         else {
 261           component = super.getTableCellRendererComponent(table, value, isSelected, false, row, column);
 262         }
 263         if (component instanceof JComponent) {
 264           ((JComponent)component).setBorder(null);
 265         }
 266         return component;
 267       }
 268     });
 269   }
 270
 271   public static void addHistoryOnExpansion(@NotNull final TextFieldWithHistory textFieldWithHistory,
 272                                            @NotNull final NotNullProducer<List<String>> historyProvider) {
 273     textFieldWithHistory.addPopupMenuListener(new PopupMenuListener() {
 274       @Override
 275       public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
 276         List<String> history = historyProvider.produce();
 277         setHistory(textFieldWithHistory, ContainerUtil.notNullize(history), true);
 278         // one-time initialization
 279         textFieldWithHistory.removePopupMenuListener(this);
 280       }
 281
 282       @Override
 283       public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
 284       }
 285
 286       @Override
 287       public void popupMenuCanceled(PopupMenuEvent e) {
 288       }
 289     });
 290   }
 291
 292   public static void setHistory(@NotNull TextFieldWithHistory textFieldWithHistory,
 293                                 @NotNull List<String> history,
 294                                 boolean mergeWithPrevHistory) {
 295     Set<String> newHistorySet = ContainerUtil.newHashSet(history);
 296     List<String> prevHistory = textFieldWithHistory.getHistory();
 297     List<String> mergedHistory = ContainerUtil.newArrayList();
 298     if (mergeWithPrevHistory) {
 299       for (String item : prevHistory) {
 300         if (!newHistorySet.contains(item)) {
 301           mergedHistory.add(item);
 302         }
 303       }
 304     }
 305     else {
 306       String currentText = textFieldWithHistory.getText();
 307       if (StringUtil.isNotEmpty(currentText) && !newHistorySet.contains(currentText)) {
 308         mergedHistory.add(currentText);
 309       }
 310     }
 311     mergedHistory.addAll(history);
 312     textFieldWithHistory.setHistory(mergedHistory);
 313     setLongestAsPrototype(textFieldWithHistory, mergedHistory);
 314   }
 315
 316   private static void setLongestAsPrototype(@NotNull JComboBox comboBox, @NotNull List<String> variants) {
 317     Object prototypeDisplayValue = comboBox.getPrototypeDisplayValue();
 318     String prototypeDisplayValueStr = null;
 319     if (prototypeDisplayValue instanceof String) {
 320       prototypeDisplayValueStr = (String)prototypeDisplayValue;
 321     }
 322     else if (prototypeDisplayValue != null) {
 323       return;
 324     }
 325     String longest = StringUtil.notNullize(prototypeDisplayValueStr);
 326     boolean updated = false;
 327     for (String s : variants) {
 328       if (longest.length() < s.length()) {
 329         longest = s;
 330         updated = true;
 331       }
 332     }
 333     if (updated) {
 334       comboBox.setPrototypeDisplayValue(longest);
 335     }
 336   }
 337
 338   public static void installFileCompletionAndBrowseDialog(@Nullable Project project,
 339                                                           @NotNull TextFieldWithHistoryWithBrowseButton textFieldWithHistoryWithBrowseButton,
 340                                                           @NotNull String browseDialogTitle,
 341                                                           @NotNull FileChooserDescriptor fileChooserDescriptor) {
 342     doInstall(project,
 343               textFieldWithHistoryWithBrowseButton,
 344               textFieldWithHistoryWithBrowseButton.getChildComponent().getTextEditor(),
 345               browseDialogTitle,
 346               fileChooserDescriptor,
 347               TextComponentAccessor.TEXT_FIELD_WITH_HISTORY_WHOLE_TEXT);
 348   }
 349
 350   public static void installFileCompletionAndBrowseDialog(@Nullable Project project,
 351                                                           @NotNull TextFieldWithBrowseButton textFieldWithBrowseButton,
 352                                                           @NotNull String browseDialogTitle,
 353                                                           @NotNull FileChooserDescriptor fileChooserDescriptor) {
 354     doInstall(project,
 355               textFieldWithBrowseButton,
 356               textFieldWithBrowseButton.getTextField(),
 357               browseDialogTitle,
 358               fileChooserDescriptor,
 359               TextComponentAccessor.TEXT_FIELD_WHOLE_TEXT);
 360   }
 361
 362   private static <T extends JComponent> void doInstall(@Nullable Project project,
 363                                                        @NotNull ComponentWithBrowseButton<T> componentWithBrowseButton,
 364                                                        @NotNull JTextField textField,
 365                                                        @NotNull String browseDialogTitle,
 366                                                        @NotNull FileChooserDescriptor fileChooserDescriptor,
 367                                                        @NotNull TextComponentAccessor<T> textComponentAccessor) {
 368     fileChooserDescriptor = fileChooserDescriptor.withShowHiddenFiles(SystemInfo.isUnix);
 369     componentWithBrowseButton.addBrowseFolderListener(
 370       project,
 371       new ComponentWithBrowseButton.BrowseFolderActionListener<T>(
 372         browseDialogTitle,
 373         null,
 374         componentWithBrowseButton,
 375         project,
 376         fileChooserDescriptor,
 377         textComponentAccessor
 378       ),
 379       true
 380     );
 381     FileChooserFactory.getInstance().installFileCompletion(
 382       textField,
 383       fileChooserDescriptor,
 384       true,
 385       project
 386     );
 387   }
 388
 389   @NotNull
 390   public static HyperlinkLabel createWebHyperlink(@NotNull String url) {
 391     return createWebHyperlink(url, url);
 392   }
 393
 394   @NotNull
 395   public static HyperlinkLabel createWebHyperlink(@NotNull String text, @NotNull String url) {
 396     HyperlinkLabel hyperlink = new HyperlinkLabel(text);
 397     hyperlink.setHyperlinkTarget(url);
 398
 399     DefaultActionGroup actionGroup = new DefaultActionGroup();
 400     actionGroup.add(new OpenLinkInBrowser(url));
 401     actionGroup.add(new CopyLinkAction(url));
 402
 403     hyperlink.setComponentPopupMenu(ActionManager.getInstance().createActionPopupMenu("web hyperlink", actionGroup).getComponent());
 404     return hyperlink;
 405   }
 406
 407   public static void setPreferredWidth(@NotNull JComponent component, int width) {
 408     Dimension preferredSize = component.getPreferredSize();
 409     preferredSize.width = width;
 410     component.setPreferredSize(preferredSize);
 411   }
 412
 413   public static class HtmlViewerBuilder {
 414     private boolean myCarryTextOver;
 415     private String myDisabledHtml;
 416     private Font myFont;
 417     private Color myBackground;
 418     private Color myForeground;
 419
 420     public JEditorPane create() {
 421       final JEditorPane textPane = new JEditorPane() {
 422         private boolean myEnabled = true;
 423         private String myEnabledHtml;
 424
 425         @Override
 426         public Dimension getPreferredSize() {
 427           // This trick makes text component to carry text over to the next line
 428           // if the text line width exceeds parent's width
 429           Dimension dimension = super.getPreferredSize();
 430           if (myCarryTextOver) {
 431             dimension.width = 0;
 432           }
 433           return dimension;
 434         }
 435
 436         @Override
 437         public void setText(String t) {
 438           if (myDisabledHtml != null) {
 439             if (myEnabled) {
 440               myEnabledHtml = t;
 441             }
 442           }
 443           super.setText(t);
 444         }
 445
 446         @Override
 447         public void setEnabled(boolean enabled) {
 448           if (myDisabledHtml != null) {
 449             myEnabled = enabled;
 450             if (myEnabled) {
 451               setText(myEnabledHtml);
 452             } else {
 453               setText(myDisabledHtml);
 454             }
 455             super.setEnabled(true);
 456           } else {
 457             super.setEnabled(enabled);
 458           }
 459         }
 460       };
 461       textPane.setFont(myFont != null ? myFont : UIUtil.getLabelFont());
 462       textPane.setContentType(UIUtil.HTML_MIME);
 463       textPane.setEditable(false);
 464       if (myBackground != null) {
 465         textPane.setBackground(myBackground);
 466       }
 467       else {
 468         textPane.setOpaque(false);
 469       }
 470       textPane.setForeground(myForeground != null ? myForeground : UIUtil.getLabelForeground());
 471       textPane.setFocusable(false);
 472       return textPane;
 473     }
 474
 475     public HtmlViewerBuilder setCarryTextOver(boolean carryTextOver) {
 476       myCarryTextOver = carryTextOver;
 477       return this;
 478     }
 479
 480     public HtmlViewerBuilder setDisabledHtml(String disabledHtml) {
 481       myDisabledHtml = disabledHtml;
 482       return this;
 483     }
 484
 485     public HtmlViewerBuilder setFont(Font font) {
 486       myFont = font;
 487       return this;
 488     }
 489
 490     public HtmlViewerBuilder setBackground(Color background) {
 491       myBackground = background;
 492       return this;
 493     }
 494
 495     public HtmlViewerBuilder setForeground(Color foreground) {
 496       myForeground = foreground;
 497       return this;
 498     }
 499   }
 500
 501   @NotNull
 502   public static JEditorPane createHtmlViewer(boolean carryTextOver,
 503                                              @Nullable Font font,
 504                                              @Nullable Color background,
 505                                              @Nullable Color foreground) {
 506     final JEditorPane textPane;
 507     if (carryTextOver) {
 508       textPane = new JEditorPane() {
 509         @Override
 510         public Dimension getPreferredSize() {
 511           // This trick makes text component to carry text over to the next line
 512           // if the text line width exceeds parent's width
 513           Dimension dimension = super.getPreferredSize();
 514           dimension.width = 0;
 515           return dimension;
 516         }
 517       };
 518     }
 519     else {
 520       textPane = new JEditorPane();
 521     }
 522     textPane.setFont(font != null ? font : UIUtil.getLabelFont());
 523     textPane.setContentType(UIUtil.HTML_MIME);
 524     textPane.setEditable(false);
 525     if (background != null) {
 526       textPane.setBackground(background);
 527     }
 528     else {
 529       textPane.setOpaque(false);
 530     }
 531     textPane.setForeground(foreground != null ? foreground : UIUtil.getLabelForeground());
 532     textPane.setFocusable(false);
 533     return textPane;
 534   }
 535
 536   public static void setHtml(@NotNull JEditorPane editorPane,
 537                              @NotNull String bodyInnerHtml,
 538                              @Nullable Color foregroundColor) {
 539     String html = String.format(
 540       "<html><head>%s</head><body>%s</body></html>",
 541       UIUtil.getCssFontDeclaration(editorPane.getFont(), foregroundColor, null, null),
 542       bodyInnerHtml
 543     );
 544     editorPane.setText(html);
 545   }
 546
 547   @NotNull
 548   public static TextFieldWithHistoryWithBrowseButton createTextFieldWithHistoryWithBrowseButton(@Nullable Project project,
 549                                                                                                 @NotNull String browseDialogTitle,
 550                                                                                                 @NotNull FileChooserDescriptor fileChooserDescriptor,
 551                                                                                                 @Nullable NotNullProducer<List<String>> historyProvider) {
 552     TextFieldWithHistoryWithBrowseButton textFieldWithHistoryWithBrowseButton = new TextFieldWithHistoryWithBrowseButton();
 553     TextFieldWithHistory textFieldWithHistory = textFieldWithHistoryWithBrowseButton.getChildComponent();
 554     textFieldWithHistory.setHistorySize(-1);
 555     textFieldWithHistory.setMinimumAndPreferredWidth(0);
 556     if (historyProvider != null) {
 557       addHistoryOnExpansion(textFieldWithHistory, historyProvider);
 558     }
 559     installFileCompletionAndBrowseDialog(
 560       project,
 561       textFieldWithHistoryWithBrowseButton,
 562       browseDialogTitle,
 563       fileChooserDescriptor
 564     );
 565     return textFieldWithHistoryWithBrowseButton;
 566   }
 567
 568   @NotNull
 569   public static <C extends JComponent> ComponentWithBrowseButton<C> wrapWithInfoButton(@NotNull final C component,
 570                                                                                        @NotNull String infoButtonTooltip,
 571                                                                                        @NotNull ActionListener listener) {
 572     ComponentWithBrowseButton<C> comp = new ComponentWithBrowseButton<C>(component, listener);
 573     FixedSizeButton uiHelpButton = comp.getButton();
 574     uiHelpButton.setToolTipText(infoButtonTooltip);
 575     uiHelpButton.setIcon(UIUtil.getBalloonInformationIcon());
 576     uiHelpButton.setHorizontalAlignment(SwingConstants.CENTER);
 577     uiHelpButton.setVerticalAlignment(SwingConstants.CENTER);
 578     return comp;
 579   }
 580
 581   private static class CopyLinkAction extends AnAction {
 582
 583     private final String myUrl;
 584
 585     private CopyLinkAction(@NotNull String url) {
 586       super("Copy Link Address", null, PlatformIcons.COPY_ICON);
 587       myUrl = url;
 588     }
 589
 590     @Override
 591     public void update(AnActionEvent e) {
 592       e.getPresentation().setEnabled(true);
 593     }
 594
 595     @Override
 596     public void actionPerformed(AnActionEvent e) {
 597       Transferable content = new StringSelection(myUrl);
 598       CopyPasteManager.getInstance().setContents(content);
 599     }
 600   }
 601
 602   private static class OpenLinkInBrowser extends AnAction {
 603
 604     private final String myUrl;
 605
 606     private OpenLinkInBrowser(@NotNull String url) {
 607       super("Open Link in Browser", null, PlatformIcons.WEB_ICON);
 608       myUrl = url;
 609     }
 610
 611     @Override
 612     public void update(AnActionEvent e) {
 613       e.getPresentation().setEnabled(true);
 614     }
 615
 616     @Override
 617     public void actionPerformed(AnActionEvent e) {
 618       BrowserUtil.browse(myUrl);
 619     }
 620   }
 621 }