53c6c19268d74cff7e2b2ebf3fb59ef53b78fcd0
[idea/community.git] / platform / lang-impl / src / com / intellij / codeInsight / lookup / impl / LookupUi.java
1 /*
2  * Copyright 2000-2015 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.codeInsight.lookup.impl;
17
18 import com.intellij.codeInsight.CodeInsightBundle;
19 import com.intellij.codeInsight.completion.CodeCompletionFeatures;
20 import com.intellij.codeInsight.completion.ShowHideIntentionIconLookupAction;
21 import com.intellij.codeInsight.hint.HintManagerImpl;
22 import com.intellij.codeInsight.lookup.LookupElement;
23 import com.intellij.codeInsight.lookup.LookupElementAction;
24 import com.intellij.featureStatistics.FeatureUsageTracker;
25 import com.intellij.icons.AllIcons;
26 import com.intellij.ide.DataManager;
27 import com.intellij.ide.ui.UISettings;
28 import com.intellij.injected.editor.EditorWindow;
29 import com.intellij.openapi.actionSystem.*;
30 import com.intellij.openapi.application.ModalityState;
31 import com.intellij.openapi.diagnostic.Logger;
32 import com.intellij.openapi.editor.Editor;
33 import com.intellij.openapi.editor.LogicalPosition;
34 import com.intellij.openapi.keymap.KeymapUtil;
35 import com.intellij.openapi.project.DumbAwareAction;
36 import com.intellij.openapi.project.Project;
37 import com.intellij.openapi.ui.popup.JBPopupFactory;
38 import com.intellij.openapi.util.ActionCallback;
39 import com.intellij.openapi.util.Disposer;
40 import com.intellij.openapi.wm.IdeFocusManager;
41 import com.intellij.ui.ClickListener;
42 import com.intellij.ui.JBColor;
43 import com.intellij.ui.ScreenUtil;
44 import com.intellij.ui.components.JBLayeredPane;
45 import com.intellij.ui.components.JBList;
46 import com.intellij.ui.components.JBScrollPane;
47 import com.intellij.util.Alarm;
48 import com.intellij.util.PlatformIcons;
49 import com.intellij.util.ui.AbstractLayoutManager;
50 import com.intellij.util.ui.ButtonlessScrollBarUI;
51 import com.intellij.util.ui.JBUI;
52 import com.intellij.util.ui.UIUtil;
53 import org.jetbrains.annotations.NotNull;
54 import org.jetbrains.annotations.Nullable;
55
56 import javax.swing.*;
57 import javax.swing.border.Border;
58 import javax.swing.border.EmptyBorder;
59 import javax.swing.border.LineBorder;
60 import javax.swing.event.ListSelectionEvent;
61 import javax.swing.event.ListSelectionListener;
62 import java.awt.*;
63 import java.awt.event.*;
64 import java.util.Collection;
65
66 /**
67  * @author peter
68  */
69 class LookupUi {
70   private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.lookup.impl.LookupUi");
71   private final LookupImpl myLookup;
72   private final Advertiser myAdvertiser;
73   private final JBList myList;
74   private final Project myProject;
75   private final ModalityState myModalityState;
76   private final Alarm myHintAlarm = new Alarm();
77   private final JLabel mySortingLabel = new JLabel();
78   private final JScrollPane myScrollPane;
79   private final JButton myScrollBarIncreaseButton;
80   private final LookupLayeredPane myLayeredPane = new LookupLayeredPane();
81
82   private LookupHint myElementHint = null;
83   private int myMaximumHeight = Integer.MAX_VALUE;
84   private Boolean myPositionedAbove = null;
85
86   LookupUi(LookupImpl lookup, Advertiser advertiser, JBList list, Project project) {
87     myLookup = lookup;
88     myAdvertiser = advertiser;
89     myList = list;
90     myProject = project;
91
92     JComponent adComponent = advertiser.getAdComponent();
93     adComponent.setBorder(new EmptyBorder(0, 1, 1, 2 + AllIcons.Ide.LookupRelevance.getIconWidth()));
94     myLayeredPane.mainPanel.add(adComponent, BorderLayout.SOUTH);
95
96     myScrollBarIncreaseButton = new JButton();
97     myScrollBarIncreaseButton.setFocusable(false);
98     myScrollBarIncreaseButton.setRequestFocusEnabled(false);
99
100     myScrollPane = new JBScrollPane(lookup.getList());
101     myScrollPane.setViewportBorder(JBUI.Borders.empty());
102     myScrollPane.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
103     myScrollPane.getVerticalScrollBar().setPreferredSize(new Dimension(13, -1));
104     myScrollPane.getVerticalScrollBar().setUI(new ButtonlessScrollBarUI() {
105       @Override
106       protected JButton createIncreaseButton(int orientation) {
107         return myScrollBarIncreaseButton;
108       }
109     });
110     lookup.getComponent().add(myLayeredPane, BorderLayout.CENTER);
111
112     //IDEA-82111
113     fixMouseCheaters();
114
115     myLayeredPane.mainPanel.add(myScrollPane, BorderLayout.CENTER);
116     myScrollPane.setBorder(null);
117
118     mySortingLabel.setBorder(new LineBorder(new JBColor(Color.LIGHT_GRAY, JBColor.background())));
119     mySortingLabel.setOpaque(true);
120     new ChangeLookupSorting().installOn(mySortingLabel);
121     updateSorting();
122     myModalityState = ModalityState.stateForComponent(lookup.getEditor().getComponent());
123
124     addListeners();
125
126     updateScrollbarVisibility();
127
128     Disposer.register(lookup, myHintAlarm);
129   }
130
131   private void addListeners() {
132     myList.addListSelectionListener(new ListSelectionListener() {
133       @Override
134       public void valueChanged(ListSelectionEvent e) {
135         if (myLookup.isLookupDisposed()) return;
136         
137         myHintAlarm.cancelAllRequests();
138
139         final LookupElement item = myLookup.getCurrentItem();
140         if (item != null) {
141           updateHint(item);
142         }
143       }
144     });
145
146     final Alarm alarm = new Alarm(myLookup);
147     myScrollPane.getVerticalScrollBar().addAdjustmentListener(new AdjustmentListener() {
148       @Override
149       public void adjustmentValueChanged(AdjustmentEvent e) {
150         if (myLookup.myUpdating || myLookup.isLookupDisposed()) return;
151         alarm.addRequest(new Runnable() {
152           @Override
153           public void run() {
154             myLookup.refreshUi(false, false);
155           }
156         }, 300, myModalityState);
157       }
158     });
159   }
160
161   private void updateScrollbarVisibility() {
162     boolean showSorting = myLookup.isCompletion() && myList.getModel().getSize() >= 3;
163     mySortingLabel.setVisible(showSorting);
164     myScrollPane.setVerticalScrollBarPolicy(showSorting ? ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS : ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);
165   }
166
167   private void updateHint(@NotNull final LookupElement item) {
168     myLookup.checkValid();
169     if (myElementHint != null) {
170       myLayeredPane.remove(myElementHint);
171       myElementHint = null;
172       final JRootPane rootPane = myLookup.getComponent().getRootPane();
173       if (rootPane != null) {
174         rootPane.revalidate();
175         rootPane.repaint();
176       }
177     }
178     if (!item.isValid()) {
179       return;
180     }
181
182     final Collection<LookupElementAction> actions = myLookup.getActionsFor(item);
183     if (!actions.isEmpty()) {
184       myHintAlarm.addRequest(new Runnable() {
185         @Override
186         public void run() {
187           if (!ShowHideIntentionIconLookupAction.shouldShowLookupHint() ||
188               ((CompletionExtender)myList.getExpandableItemsHandler()).isShowing()) {
189             return;
190           }
191           myElementHint = new LookupHint();
192           myLayeredPane.add(myElementHint, 20, 0);
193           myLayeredPane.layoutHint();
194         }
195       }, 500, myModalityState);
196     }
197   }
198
199   //Yes, it's possible to move focus to the hint. It's inconvenient, it doesn't make sense, but it's possible.
200   // This fix is for those jerks
201   private void fixMouseCheaters() {
202     myLookup.getComponent().addFocusListener(new FocusAdapter() {
203       @Override
204       public void focusGained(FocusEvent e) {
205         final ActionCallback done = IdeFocusManager.getInstance(myProject).requestFocus(myLookup.getEditor().getContentComponent(), true);
206         IdeFocusManager.getInstance(myProject).typeAheadUntil(done);
207         new Alarm(myLookup).addRequest(new Runnable() {
208           @Override
209           public void run() {
210             if (!done.isDone()) {
211               done.setDone();
212             }
213           }
214         }, 300, myModalityState);
215       }
216     });
217   }
218
219   void setCalculating(final boolean calculating) {
220     Runnable setVisible = new Runnable() {
221       @Override
222       public void run() {
223         myList.setPaintBusy(myLookup.isCalculating());
224       }
225     };
226     if (myLookup.isCalculating()) {
227       new Alarm(myLookup).addRequest(setVisible, 100, myModalityState);
228     } else {
229       setVisible.run();
230     }
231   }
232
233   private void updateSorting() {
234     final boolean lexi = UISettings.getInstance().SORT_LOOKUP_ELEMENTS_LEXICOGRAPHICALLY;
235     mySortingLabel.setIcon(lexi ? AllIcons.Ide.LookupAlphanumeric : AllIcons.Ide.LookupRelevance);
236     mySortingLabel.setToolTipText(lexi ? "Click to sort variants by relevance" : "Click to sort variants alphabetically");
237
238     myLookup.resort(false);
239   }
240
241   void refreshUi(boolean selectionVisible, boolean itemsChanged, boolean reused, boolean onExplicitAction) {
242     Editor editor = myLookup.getEditor();
243     if (editor.getComponent().getRootPane() == null || editor instanceof EditorWindow && !((EditorWindow)editor).isValid()) {
244       return;
245     }
246
247     updateScrollbarVisibility();
248
249     if (myLookup.myResizePending || itemsChanged) {
250       myMaximumHeight = Integer.MAX_VALUE;
251     }
252     Rectangle rectangle = calculatePosition();
253     myMaximumHeight = rectangle.height;
254
255     if (myLookup.myResizePending || itemsChanged) {
256       myLookup.myResizePending = false;
257       myLookup.pack();
258     }
259     HintManagerImpl.updateLocation(myLookup, editor, rectangle.getLocation());
260
261     if (reused || selectionVisible || onExplicitAction) {
262       myLookup.ensureSelectionVisible(false);
263     }
264   }
265
266   boolean isPositionedAboveCaret() {
267     return myPositionedAbove != null && myPositionedAbove.booleanValue();
268   }
269
270   // in layered pane coordinate system.
271   Rectangle calculatePosition() {
272     final JComponent lookupComponent = myLookup.getComponent();
273     Dimension dim = lookupComponent.getPreferredSize();
274     int lookupStart = myLookup.getLookupStart();
275     Editor editor = myLookup.getEditor();
276     if (lookupStart < 0 || lookupStart > editor.getDocument().getTextLength()) {
277       LOG.error(lookupStart + "; offset=" + editor.getCaretModel().getOffset() + "; element=" +
278                 myLookup.getPsiElement());
279     }
280
281     LogicalPosition pos = editor.offsetToLogicalPosition(lookupStart);
282     Point location = editor.logicalPositionToXY(pos);
283     location.y += editor.getLineHeight();
284     location.x -= myLookup.myCellRenderer.getTextIndent();
285     // extra check for other borders
286     final Window window = UIUtil.getWindow(lookupComponent);
287     if (window != null) {
288       final Point point = SwingUtilities.convertPoint(lookupComponent, 0, 0, window);
289       location.x -= point.x;
290     }
291
292     SwingUtilities.convertPointToScreen(location, editor.getContentComponent());
293     final Rectangle screenRectangle = ScreenUtil.getScreenRectangle(location);
294
295     if (!isPositionedAboveCaret()) {
296       int shiftLow = screenRectangle.height - (location.y + dim.height);
297       myPositionedAbove = shiftLow < 0 && shiftLow < location.y - dim.height && location.y >= dim.height;
298     }
299     if (isPositionedAboveCaret()) {
300       location.y -= dim.height + editor.getLineHeight();
301       if (pos.line == 0) {
302         location.y += 1;
303         //otherwise the lookup won't intersect with the editor and every editor's resize (e.g. after typing in console) will close the lookup
304       }
305     }
306
307     if (!screenRectangle.contains(location)) {
308       location = ScreenUtil.findNearestPointOnBorder(screenRectangle, location);
309     }
310
311     final JRootPane rootPane = editor.getComponent().getRootPane();
312     if (rootPane == null) {
313       LOG.error("editor.disposed=" + editor.isDisposed() + "; lookup.disposed=" + myLookup.isLookupDisposed() + "; editorShowing=" + editor.getContentComponent().isShowing());
314     }
315     Rectangle candidate = new Rectangle(location, dim);
316     ScreenUtil.cropRectangleToFitTheScreen(candidate);
317
318     SwingUtilities.convertPointFromScreen(location, rootPane.getLayeredPane());
319     myMaximumHeight = candidate.height;
320     return new Rectangle(location.x, location.y, dim.width, candidate.height);
321   }
322
323   private class LookupLayeredPane extends JBLayeredPane {
324     final JPanel mainPanel = new JPanel(new BorderLayout());
325
326     private LookupLayeredPane() {
327       add(mainPanel, 0, 0);
328       add(mySortingLabel, 10, 0);
329
330       setLayout(new AbstractLayoutManager() {
331         @Override
332         public Dimension preferredLayoutSize(@Nullable Container parent) {
333           int maxCellWidth = myLookup.myLookupTextWidth + myLookup.myCellRenderer.getTextIndent();
334           int scrollBarWidth = myScrollPane.getPreferredSize().width - myScrollPane.getViewport().getPreferredSize().width;
335           int listWidth = Math.min(scrollBarWidth + maxCellWidth, UISettings.getInstance().MAX_LOOKUP_WIDTH2);
336
337           Dimension adSize = myAdvertiser.getAdComponent().getPreferredSize();
338
339           int panelHeight = myList.getPreferredScrollableViewportSize().height + adSize.height;
340           if (myList.getModel().getSize() > myList.getVisibleRowCount() && myList.getVisibleRowCount() >= 5) {
341             panelHeight -= myList.getFixedCellHeight() / 2;
342           }
343           return new Dimension(Math.max(listWidth, adSize.width), Math.min(panelHeight, myMaximumHeight));
344         }
345
346         @Override
347         public void layoutContainer(Container parent) {
348           Dimension size = getSize();
349           mainPanel.setSize(size);
350           mainPanel.validate();
351
352           if (!myLookup.myResizePending) {
353             Dimension preferredSize = preferredLayoutSize(null);
354             if (preferredSize.width != size.width) {
355               UISettings.getInstance().MAX_LOOKUP_WIDTH2 = Math.max(500, size.width);
356             }
357
358             int listHeight = myList.getLastVisibleIndex() - myList.getFirstVisibleIndex() + 1;
359             if (listHeight != myList.getModel().getSize() && listHeight != myList.getVisibleRowCount() && preferredSize.height != size.height) {
360               UISettings.getInstance().MAX_LOOKUP_LIST_HEIGHT = Math.max(5, listHeight);
361             }
362           }
363
364           myList.setFixedCellWidth(myScrollPane.getViewport().getWidth());
365           layoutStatusIcons();
366           layoutHint();
367         }
368       });
369     }
370
371     private void layoutStatusIcons() {
372       int adHeight = myAdvertiser.getAdComponent().getPreferredSize().height;
373       Dimension buttonSize = adHeight > 0 || !mySortingLabel.isVisible() ? new Dimension(0, 0) : new Dimension(
374         AllIcons.Ide.LookupRelevance.getIconWidth(), AllIcons.Ide.LookupRelevance.getIconHeight());
375       myScrollBarIncreaseButton.setPreferredSize(buttonSize);
376       myScrollBarIncreaseButton.setMinimumSize(buttonSize);
377       myScrollBarIncreaseButton.setMaximumSize(buttonSize);
378       JScrollBar vScrollBar = myScrollPane.getVerticalScrollBar();
379       vScrollBar.revalidate();
380       vScrollBar.repaint();
381       
382       final Dimension sortSize = mySortingLabel.getPreferredSize();
383       final int sortWidth = vScrollBar.isVisible() ? vScrollBar.getWidth() : sortSize.width;
384       final int sortHeight = Math.max(sortSize.height, adHeight);
385       mySortingLabel.setBounds(getWidth() - sortWidth, getHeight() - sortHeight, sortSize.width, sortHeight);
386     }
387
388     void layoutHint() {
389       if (myElementHint != null && myLookup.getCurrentItem() != null) {
390         final Rectangle bounds = myLookup.getCurrentItemBounds();
391         myElementHint.setSize(myElementHint.getPreferredSize());
392
393         JScrollBar sb = myScrollPane.getVerticalScrollBar();
394         int x = bounds.x + bounds.width - myElementHint.getWidth() + (sb.isVisible() ? sb.getWidth() : 0);
395         x = Math.min(x, getWidth() - myElementHint.getWidth());
396         myElementHint.setLocation(new Point(x, bounds.y));
397       }
398     }
399   }
400
401   private class LookupHint extends JLabel {
402     private final Border INACTIVE_BORDER = BorderFactory.createEmptyBorder(2, 2, 2, 2);
403     private final Border ACTIVE_BORDER = BorderFactory.createCompoundBorder(BorderFactory.createLineBorder(Color.BLACK, 1), BorderFactory.createEmptyBorder(1, 1, 1, 1));
404     private LookupHint() {
405       setOpaque(false);
406       setBorder(INACTIVE_BORDER);
407       setIcon(AllIcons.Actions.IntentionBulb);
408       String acceleratorsText = KeymapUtil.getFirstKeyboardShortcutText(
409         ActionManager.getInstance().getAction(IdeActions.ACTION_SHOW_INTENTION_ACTIONS));
410       if (acceleratorsText.length() > 0) {
411         setToolTipText(CodeInsightBundle.message("lightbulb.tooltip", acceleratorsText));
412       }
413
414       addMouseListener(new MouseAdapter() {
415         @Override
416         public void mouseEntered(MouseEvent e) {
417           setBorder(ACTIVE_BORDER);
418         }
419
420         @Override
421         public void mouseExited(MouseEvent e) {
422           setBorder(INACTIVE_BORDER);
423         }
424         @Override
425         public void mousePressed(MouseEvent e) {
426           if (!e.isPopupTrigger() && e.getButton() == MouseEvent.BUTTON1) {
427             myLookup.showElementActions();
428           }
429         }
430       });
431     }
432   }
433
434   private class ChangeLookupSorting extends ClickListener {
435
436     @Override
437     public boolean onClick(@NotNull MouseEvent e, int clickCount) {
438       DataContext context = DataManager.getInstance().getDataContext(mySortingLabel);
439       DefaultActionGroup group = new DefaultActionGroup();
440       group.add(createSortingAction(true));
441       group.add(createSortingAction(false));
442       JBPopupFactory.getInstance().createActionGroupPopup("Change sorting", group, context, JBPopupFactory.ActionSelectionAid.SPEEDSEARCH, false).showInBestPositionFor(
443         context);
444       return true;
445     }
446
447     private AnAction createSortingAction(boolean checked) {
448       boolean currentSetting = UISettings.getInstance().SORT_LOOKUP_ELEMENTS_LEXICOGRAPHICALLY;
449       final boolean newSetting = checked ? currentSetting : !currentSetting;
450       return new DumbAwareAction(newSetting ? "Sort lexicographically" : "Sort by relevance", null, checked ? PlatformIcons.CHECK_ICON : null) {
451         @Override
452         public void actionPerformed(AnActionEvent e) {
453           FeatureUsageTracker.getInstance().triggerFeatureUsed(CodeCompletionFeatures.EDITING_COMPLETION_CHANGE_SORTING);
454           UISettings.getInstance().SORT_LOOKUP_ELEMENTS_LEXICOGRAPHICALLY = newSetting;
455           updateSorting();
456         }
457       };
458     }
459   }
460 }