| /******************************************************************************* |
| * Copyright (c) 2005, 2008 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.ui.internal.quickaccess; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.core.commands.Command; |
| import org.eclipse.core.runtime.Assert; |
| import org.eclipse.jface.bindings.TriggerSequence; |
| import org.eclipse.jface.bindings.keys.KeySequence; |
| import org.eclipse.jface.bindings.keys.SWTKeySupport; |
| import org.eclipse.jface.dialogs.IDialogSettings; |
| import org.eclipse.jface.dialogs.PopupDialog; |
| import org.eclipse.jface.layout.GridDataFactory; |
| import org.eclipse.jface.layout.GridLayoutFactory; |
| import org.eclipse.jface.layout.TableColumnLayout; |
| import org.eclipse.jface.resource.FontDescriptor; |
| import org.eclipse.jface.resource.ImageDescriptor; |
| import org.eclipse.jface.resource.JFaceResources; |
| import org.eclipse.jface.resource.LocalResourceManager; |
| import org.eclipse.jface.viewers.ColumnWeightData; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.custom.BusyIndicator; |
| import org.eclipse.swt.events.ControlAdapter; |
| import org.eclipse.swt.events.ControlEvent; |
| import org.eclipse.swt.events.KeyAdapter; |
| import org.eclipse.swt.events.KeyEvent; |
| import org.eclipse.swt.events.KeyListener; |
| import org.eclipse.swt.events.ModifyEvent; |
| import org.eclipse.swt.events.ModifyListener; |
| import org.eclipse.swt.events.MouseAdapter; |
| import org.eclipse.swt.events.MouseEvent; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.events.SelectionListener; |
| import org.eclipse.swt.graphics.Color; |
| import org.eclipse.swt.graphics.Font; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.eclipse.swt.graphics.TextLayout; |
| import org.eclipse.swt.graphics.TextStyle; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Event; |
| import org.eclipse.swt.widgets.Listener; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.swt.widgets.Table; |
| import org.eclipse.swt.widgets.TableColumn; |
| import org.eclipse.swt.widgets.TableItem; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.internal.IWorkbenchGraphicConstants; |
| import org.eclipse.ui.internal.WorkbenchImages; |
| import org.eclipse.ui.internal.WorkbenchPlugin; |
| import org.eclipse.ui.internal.progress.ProgressManagerUtil; |
| import org.eclipse.ui.keys.IBindingService; |
| import org.eclipse.ui.themes.ColorUtil; |
| |
| |
| /** |
| * @since 3.3 |
| * |
| */ |
| public class QuickAccessDialog extends PopupDialog { |
| private static final int INITIAL_COUNT_PER_PROVIDER = 5; |
| private static final int MAX_COUNT_TOTAL = 20; |
| |
| private Text filterText; |
| |
| private QuickAccessProvider[] providers; |
| private IWorkbenchWindow window; |
| |
| private Table table; |
| |
| private LocalResourceManager resourceManager = new LocalResourceManager( |
| JFaceResources.getResources()); |
| |
| private static final String TEXT_ARRAY = "textArray"; //$NON-NLS-1$ |
| private static final String TEXT_ENTRIES = "textEntries"; //$NON-NLS-1$ |
| private static final String ORDERED_PROVIDERS = "orderedProviders"; //$NON-NLS-1$ |
| private static final String ORDERED_ELEMENTS = "orderedElements"; //$NON-NLS-1$ |
| static final int MAXIMUM_NUMBER_OF_ELEMENTS = 60; |
| static final int MAXIMUM_NUMBER_OF_TEXT_ENTRIES_PER_ELEMENT = 3; |
| |
| protected String rememberedText; |
| |
| protected Map textMap = new HashMap(); |
| |
| protected Map elementMap = new HashMap(); |
| |
| private LinkedList previousPicksList = new LinkedList(); |
| |
| protected Map providerMap; |
| // private Font italicsFont; |
| private Color grayColor; |
| private TextLayout textLayout; |
| private TriggerSequence[] invokingCommandKeySequences; |
| private Command invokingCommand; |
| private KeyAdapter keyAdapter; |
| private boolean showAllMatches = false; |
| protected boolean resized = false; |
| |
| |
| QuickAccessDialog(IWorkbenchWindow window, final Command invokingCommand) { |
| super(ProgressManagerUtil.getDefaultParent(), SWT.RESIZE, true, true, // persist size |
| false, // but not location |
| true, true, null, |
| QuickAccessMessages.QuickAccess_StartTypingToFindMatches); |
| |
| this.window = window; |
| BusyIndicator.showWhile(window.getShell() == null ? null : window |
| .getShell().getDisplay(), new Runnable() { |
| public void run() { |
| QuickAccessDialog.this.providers = new QuickAccessProvider[] { |
| new PreviousPicksProvider(), new EditorProvider(), |
| new ViewProvider(), new PerspectiveProvider(), |
| new CommandProvider(), new ActionProvider(), |
| new WizardProvider(), new PreferenceProvider(), |
| new PropertiesProvider() }; |
| providerMap = new HashMap(); |
| for (int i = 0; i < providers.length; i++) { |
| providerMap.put(providers[i].getId(), providers[i]); |
| } |
| restoreDialog(); |
| QuickAccessDialog.this.invokingCommand = invokingCommand; |
| if (QuickAccessDialog.this.invokingCommand != null |
| && !QuickAccessDialog.this.invokingCommand.isDefined()) { |
| QuickAccessDialog.this.invokingCommand = null; |
| } else { |
| // Pre-fetch key sequence - do not change because scope will |
| // change later. |
| getInvokingCommandKeySequences(); |
| } |
| // create early |
| create(); |
| } |
| }); |
| // Ugly hack to avoid bug 184045. If this gets fixed, replace the |
| // following code with a call to refresh(""). |
| getShell().getDisplay().asyncExec(new Runnable() { |
| public void run() { |
| final Shell shell = getShell(); |
| if (shell != null && !shell.isDisposed()) { |
| Point size = shell.getSize(); |
| shell.setSize(size.x, size.y + 1); |
| } |
| } |
| }); |
| } |
| |
| protected Control createTitleControl(Composite parent) { |
| filterText = new Text(parent, SWT.NONE); |
| |
| GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER).grab(true, false) |
| .applyTo(filterText); |
| |
| filterText.addKeyListener(getKeyAdapter()); |
| filterText.addKeyListener(new KeyListener() { |
| public void keyPressed(KeyEvent e) { |
| if (e.keyCode == 0x0D) { |
| handleSelection(); |
| return; |
| } else if (e.keyCode == SWT.ARROW_DOWN) { |
| int index = table.getSelectionIndex(); |
| if (index != -1 && table.getItemCount() > index + 1) { |
| table.setSelection(index + 1); |
| } |
| table.setFocus(); |
| } else if (e.keyCode == SWT.ARROW_UP) { |
| int index = table.getSelectionIndex(); |
| if (index != -1 && index >= 1) { |
| table.setSelection(index - 1); |
| table.setFocus(); |
| } |
| } else if (e.character == 0x1B) // ESC |
| close(); |
| } |
| |
| public void keyReleased(KeyEvent e) { |
| // do nothing |
| } |
| }); |
| filterText.addModifyListener(new ModifyListener() { |
| public void modifyText(ModifyEvent e) { |
| String text = ((Text) e.widget).getText().toLowerCase(); |
| refresh(text); |
| } |
| }); |
| |
| return filterText; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.dialogs.PopupDialog#createDialogArea(org.eclipse.swt.widgets.Composite) |
| */ |
| protected Control createDialogArea(Composite parent) { |
| Composite composite = (Composite) super.createDialogArea(parent); |
| boolean isWin32 = "win32".equals(SWT.getPlatform()); //$NON-NLS-1$ |
| GridLayoutFactory.fillDefaults().extendedMargins(isWin32 ? 0 : 3, 3, 2, 2).applyTo(composite); |
| Composite tableComposite = new Composite(composite, SWT.NONE); |
| GridDataFactory.fillDefaults().grab(true, true).applyTo(tableComposite); |
| TableColumnLayout tableColumnLayout = new TableColumnLayout(); |
| tableComposite.setLayout(tableColumnLayout); |
| table = new Table(tableComposite, SWT.SINGLE | SWT.FULL_SELECTION); |
| textLayout = new TextLayout(table.getDisplay()); |
| textLayout.setOrientation(getDefaultOrientation()); |
| Font boldFont = resourceManager.createFont(FontDescriptor.createFrom( |
| JFaceResources.getDialogFont()).setStyle(SWT.BOLD)); |
| textLayout.setFont(table.getFont()); |
| textLayout.setText(QuickAccessMessages.QuickAccess_AvailableCategories); |
| int maxProviderWidth = (int) (textLayout.getBounds().width * 1.1); |
| textLayout.setFont(boldFont); |
| for (int i = 0; i < providers.length; i++) { |
| QuickAccessProvider provider = providers[i]; |
| textLayout.setText(provider.getName()); |
| int width = (int) (textLayout.getBounds().width * 1.1); |
| if (width > maxProviderWidth) { |
| maxProviderWidth = width; |
| } |
| } |
| tableColumnLayout.setColumnData(new TableColumn(table, SWT.NONE), |
| new ColumnWeightData(0, maxProviderWidth)); |
| tableColumnLayout.setColumnData(new TableColumn(table, SWT.NONE), |
| new ColumnWeightData(100, 100)); |
| table.getShell().addControlListener(new ControlAdapter() { |
| public void controlResized(ControlEvent e) { |
| if (!showAllMatches) { |
| if (!resized) { |
| resized = true; |
| e.display.timerExec(100, new Runnable() { |
| public void run() { |
| if (getShell() != null |
| && !getShell().isDisposed()) { |
| refresh(filterText.getText().toLowerCase()); |
| } |
| resized = false; |
| } |
| }); |
| } |
| } |
| } |
| }); |
| |
| table.addKeyListener(getKeyAdapter()); |
| table.addKeyListener(new KeyListener() { |
| public void keyPressed(KeyEvent e) { |
| if (e.keyCode == SWT.ARROW_UP && table.getSelectionIndex() == 0) { |
| filterText.setFocus(); |
| } else if (e.character == SWT.ESC) { |
| close(); |
| } |
| } |
| |
| public void keyReleased(KeyEvent e) { |
| // do nothing |
| } |
| }); |
| table.addMouseListener(new MouseAdapter() { |
| public void mouseUp(MouseEvent e) { |
| |
| if (table.getSelectionCount() < 1) |
| return; |
| |
| if (e.button != 1) |
| return; |
| |
| if (table.equals(e.getSource())) { |
| Object o= table.getItem(new Point(e.x, e.y)); |
| TableItem selection= table.getSelection()[0]; |
| if (selection.equals(o)) |
| handleSelection(); |
| } |
| } |
| }); |
| |
| table.addSelectionListener(new SelectionListener() { |
| public void widgetSelected(SelectionEvent e) { |
| // do nothing |
| } |
| |
| public void widgetDefaultSelected(SelectionEvent e) { |
| handleSelection(); |
| } |
| }); |
| |
| // italicsFont = resourceManager.createFont(FontDescriptor.createFrom( |
| // table.getFont()).setStyle(SWT.ITALIC)); |
| grayColor = resourceManager.createColor(ColorUtil.blend(table |
| .getBackground().getRGB(), table.getForeground().getRGB())); |
| final TextStyle boldStyle = new TextStyle(boldFont, null, null); |
| Listener listener = new Listener() { |
| public void handleEvent(Event event) { |
| QuickAccessEntry entry = (QuickAccessEntry) event.item |
| .getData(); |
| if (entry != null) { |
| switch (event.type) { |
| case SWT.MeasureItem: |
| entry.measure(event, textLayout, resourceManager, |
| boldStyle); |
| break; |
| case SWT.PaintItem: |
| entry.paint(event, textLayout, resourceManager, |
| boldStyle, grayColor); |
| break; |
| case SWT.EraseItem: |
| entry.erase(event); |
| break; |
| } |
| } |
| } |
| }; |
| table.addListener(SWT.MeasureItem, listener); |
| table.addListener(SWT.EraseItem, listener); |
| table.addListener(SWT.PaintItem, listener); |
| |
| return composite; |
| } |
| |
| /** |
| * |
| */ |
| private int computeNumberOfItems() { |
| Rectangle rect = table.getClientArea (); |
| int itemHeight = table.getItemHeight (); |
| int headerHeight = table.getHeaderHeight (); |
| return (rect.height - headerHeight + itemHeight - 1) / (itemHeight + table.getGridLineWidth()); |
| } |
| |
| /** |
| * |
| */ |
| private void refresh(String filter) { |
| int numItems = computeNumberOfItems(); |
| |
| // perfect match, to be selected in the table if not null |
| QuickAccessElement perfectMatch = (QuickAccessElement) elementMap |
| .get(filter); |
| |
| List[] entries = computeMatchingEntries(filter, perfectMatch, numItems); |
| |
| int selectionIndex = refreshTable(perfectMatch, entries); |
| |
| if (table.getItemCount() > 0) { |
| table.setSelection(selectionIndex); |
| } else if (filter.length() == 0) { |
| { |
| TableItem item = new TableItem(table, SWT.NONE); |
| item.setText(0, |
| QuickAccessMessages.QuickAccess_AvailableCategories); |
| item.setForeground(0, grayColor); |
| } |
| for (int i = 0; i < providers.length; i++) { |
| QuickAccessProvider provider = providers[i]; |
| TableItem item = new TableItem(table, SWT.NONE); |
| item.setText(1, provider.getName()); |
| item.setForeground(1, grayColor); |
| } |
| } |
| |
| if (filter.length() == 0) { |
| setInfoText(QuickAccessMessages.QuickAccess_StartTypingToFindMatches); |
| } else { |
| TriggerSequence[] sequences = getInvokingCommandKeySequences(); |
| if (showAllMatches || sequences == null || sequences.length == 0) { |
| setInfoText(""); //$NON-NLS-1$ |
| } else { |
| setInfoText(NLS |
| .bind( |
| QuickAccessMessages.QuickAccess_PressKeyToShowAllMatches, |
| sequences[0].format())); |
| } |
| } |
| } |
| |
| final protected TriggerSequence[] getInvokingCommandKeySequences() { |
| if (invokingCommandKeySequences == null) { |
| if (invokingCommand != null) { |
| IBindingService bindingService = (IBindingService) window |
| .getWorkbench().getAdapter(IBindingService.class); |
| invokingCommandKeySequences = bindingService |
| .getActiveBindingsFor(invokingCommand.getId()); |
| } |
| } |
| return invokingCommandKeySequences; |
| } |
| |
| private KeyAdapter getKeyAdapter() { |
| if (keyAdapter == null) { |
| keyAdapter = new KeyAdapter() { |
| public void keyPressed(KeyEvent e) { |
| int accelerator = SWTKeySupport |
| .convertEventToUnmodifiedAccelerator(e); |
| KeySequence keySequence = KeySequence |
| .getInstance(SWTKeySupport |
| .convertAcceleratorToKeyStroke(accelerator)); |
| TriggerSequence[] sequences = getInvokingCommandKeySequences(); |
| if (sequences == null) |
| return; |
| for (int i = 0; i < sequences.length; i++) { |
| if (sequences[i].equals(keySequence)) { |
| e.doit = false; |
| toggleShowAllMatches(); |
| return; |
| } |
| } |
| } |
| }; |
| } |
| return keyAdapter; |
| } |
| |
| private void toggleShowAllMatches() { |
| showAllMatches = !showAllMatches; |
| refresh(filterText.getText().toLowerCase()); |
| } |
| |
| private int refreshTable(QuickAccessElement perfectMatch, List[] entries) { |
| if (table.getItemCount() > entries.length |
| && table.getItemCount() - entries.length > 20) { |
| table.removeAll(); |
| } |
| TableItem[] items = table.getItems(); |
| int selectionIndex = -1; |
| int index = 0; |
| for (int i = 0; i < providers.length; i++) { |
| if (entries[i] != null) { |
| boolean firstEntry = true; |
| for (Iterator it = entries[i].iterator(); it.hasNext();) { |
| QuickAccessEntry entry = (QuickAccessEntry) it.next(); |
| entry.firstInCategory = firstEntry; |
| firstEntry = false; |
| if (!it.hasNext()) { |
| entry.lastInCategory = true; |
| } |
| TableItem item; |
| if (index < items.length) { |
| item = items[index]; |
| table.clear(index); |
| } else { |
| item = new TableItem(table, SWT.NONE); |
| } |
| if (perfectMatch == entry.element && selectionIndex == -1) { |
| selectionIndex = index; |
| } |
| item.setData(entry); |
| item.setText(0, entry.provider.getName()); |
| item.setText(1, entry.element.getLabel()); |
| if (SWT.getPlatform().equals("wpf")) { //$NON-NLS-1$ |
| item.setImage(1, entry.getImage(entry.element, |
| resourceManager)); |
| } |
| index++; |
| } |
| } |
| } |
| if (index < items.length) { |
| table.remove(index, items.length - 1); |
| } |
| if (selectionIndex == -1) { |
| selectionIndex = 0; |
| } |
| return selectionIndex; |
| } |
| |
| private List[] computeMatchingEntries(String filter, |
| QuickAccessElement perfectMatch, int maxCount) { |
| // collect matches in an array of lists |
| List[] entries = new ArrayList[providers.length]; |
| int[] indexPerProvider = new int[providers.length]; |
| int countPerProvider = Math.min(maxCount / 4, |
| INITIAL_COUNT_PER_PROVIDER); |
| int countTotal = 0; |
| boolean perfectMatchAdded = true; |
| if (perfectMatch != null) { |
| // reserve one entry for the perfect match |
| maxCount--; |
| perfectMatchAdded = false; |
| } |
| boolean done; |
| do { |
| // will be set to false if we find a provider with remaining |
| // elements |
| done = true; |
| for (int i = 0; i < providers.length |
| && (showAllMatches || countTotal < maxCount); i++) { |
| if (entries[i] == null) { |
| entries[i] = new ArrayList(); |
| indexPerProvider[i] = 0; |
| } |
| int count = 0; |
| QuickAccessProvider provider = providers[i]; |
| if (filter.length() > 0 |
| || provider instanceof PreviousPicksProvider |
| || showAllMatches) { |
| QuickAccessElement[] elements = provider |
| .getElementsSorted(); |
| int j = indexPerProvider[i]; |
| while (j < elements.length |
| && (showAllMatches || (count < countPerProvider && countTotal < maxCount))) { |
| QuickAccessElement element = elements[j]; |
| QuickAccessEntry entry; |
| if (filter.length() == 0) { |
| if (i == 0 || showAllMatches) { |
| entry = new QuickAccessEntry(element, provider, |
| new int[0][0], new int[0][0]); |
| } else { |
| entry = null; |
| } |
| } else { |
| entry = element.match(filter, provider); |
| } |
| if (entry != null) { |
| entries[i].add(entry); |
| count++; |
| countTotal++; |
| if (i == 0 && entry.element == perfectMatch) { |
| perfectMatchAdded = true; |
| maxCount = MAX_COUNT_TOTAL; |
| } |
| } |
| j++; |
| } |
| indexPerProvider[i] = j; |
| if (j < elements.length) { |
| done = false; |
| } |
| } |
| } |
| // from now on, add one element per provider |
| countPerProvider = 1; |
| } while ((showAllMatches || countTotal < maxCount) && !done); |
| if (!perfectMatchAdded) { |
| QuickAccessEntry entry = perfectMatch.match(filter, providers[0]); |
| if (entry != null) { |
| if (entries[0] == null) { |
| entries[0] = new ArrayList(); |
| indexPerProvider[0] = 0; |
| } |
| entries[0].add(entry); |
| } |
| } |
| return entries; |
| } |
| |
| protected Control getFocusControl() { |
| return filterText; |
| } |
| |
| public boolean close() { |
| storeDialog(getDialogSettings()); |
| if (textLayout != null && !textLayout.isDisposed()) { |
| textLayout.dispose(); |
| } |
| if (resourceManager != null) { |
| resourceManager.dispose(); |
| resourceManager = null; |
| } |
| return super.close(); |
| } |
| |
| protected Point getDefaultSize() { |
| return new Point(350, 420); |
| } |
| |
| protected Point getDefaultLocation(Point initialSize) { |
| Point size = new Point(400, 400); |
| Rectangle parentBounds = getParentShell().getBounds(); |
| int x = parentBounds.x + parentBounds.width / 2 - size.x / 2; |
| int y = parentBounds.y + parentBounds.height / 2 - size.y / 2; |
| return new Point(x, y); |
| } |
| |
| protected IDialogSettings getDialogSettings() { |
| final IDialogSettings workbenchDialogSettings = WorkbenchPlugin |
| .getDefault().getDialogSettings(); |
| IDialogSettings result = workbenchDialogSettings.getSection(getId()); |
| if (result == null) { |
| result = workbenchDialogSettings.addNewSection(getId()); |
| } |
| return result; |
| } |
| |
| protected String getId() { |
| return "org.eclipse.ui.internal.QuickAccess"; //$NON-NLS-1$ |
| } |
| |
| private void storeDialog(IDialogSettings dialogSettings) { |
| String[] orderedElements = new String[previousPicksList.size()]; |
| String[] orderedProviders = new String[previousPicksList.size()]; |
| String[] textEntries = new String[previousPicksList.size()]; |
| ArrayList arrayList = new ArrayList(); |
| for (int i = 0; i < orderedElements.length; i++) { |
| QuickAccessElement quickAccessElement = (QuickAccessElement) previousPicksList |
| .get(i); |
| ArrayList elementText = (ArrayList) textMap.get(quickAccessElement); |
| Assert.isNotNull(elementText); |
| orderedElements[i] = quickAccessElement.getId(); |
| orderedProviders[i] = quickAccessElement.getProvider().getId(); |
| arrayList.addAll(elementText); |
| textEntries[i] = elementText.size() + ""; //$NON-NLS-1$ |
| } |
| String[] textArray = (String[]) arrayList.toArray(new String[arrayList |
| .size()]); |
| dialogSettings.put(ORDERED_ELEMENTS, orderedElements); |
| dialogSettings.put(ORDERED_PROVIDERS, orderedProviders); |
| dialogSettings.put(TEXT_ENTRIES, textEntries); |
| dialogSettings.put(TEXT_ARRAY, textArray); |
| } |
| |
| private void restoreDialog() { |
| IDialogSettings dialogSettings = getDialogSettings(); |
| if (dialogSettings != null) { |
| String[] orderedElements = dialogSettings |
| .getArray(ORDERED_ELEMENTS); |
| String[] orderedProviders = dialogSettings |
| .getArray(ORDERED_PROVIDERS); |
| String[] textEntries = dialogSettings.getArray(TEXT_ENTRIES); |
| String[] textArray = dialogSettings.getArray(TEXT_ARRAY); |
| elementMap = new HashMap(); |
| textMap = new HashMap(); |
| previousPicksList = new LinkedList(); |
| if (orderedElements != null && orderedProviders != null |
| && textEntries != null && textArray != null) { |
| int arrayIndex = 0; |
| for (int i = 0; i < orderedElements.length; i++) { |
| QuickAccessProvider quickAccessProvider = (QuickAccessProvider) providerMap |
| .get(orderedProviders[i]); |
| int numTexts = Integer.parseInt(textEntries[i]); |
| if (quickAccessProvider != null) { |
| QuickAccessElement quickAccessElement = quickAccessProvider |
| .getElementForId(orderedElements[i]); |
| if (quickAccessElement != null) { |
| ArrayList arrayList = new ArrayList(); |
| for (int j = arrayIndex; j < arrayIndex + numTexts; j++) { |
| String text = textArray[j]; |
| // text length can be zero for old workspaces, see bug 190006 |
| if (text.length() > 0) { |
| arrayList.add(text); |
| elementMap.put(text, quickAccessElement); |
| } |
| } |
| textMap.put(quickAccessElement, arrayList); |
| previousPicksList.add(quickAccessElement); |
| } |
| } |
| arrayIndex += numTexts; |
| } |
| } |
| } |
| } |
| |
| protected void handleElementSelected(String text, Object selectedElement) { |
| IWorkbenchPage activePage = window.getActivePage(); |
| if (activePage != null) { |
| if (selectedElement instanceof QuickAccessElement) { |
| addPreviousPick(text, selectedElement); |
| storeDialog(getDialogSettings()); |
| QuickAccessElement element = (QuickAccessElement) selectedElement; |
| element.execute(); |
| } |
| } |
| } |
| |
| /** |
| * @param element |
| */ |
| private void addPreviousPick(String text, Object element) { |
| // previousPicksList: |
| // Remove element from previousPicksList so there are no duplicates |
| // If list is max size, remove last(oldest) element |
| // Remove entries for removed element from elementMap and textMap |
| // Add element to front of previousPicksList |
| previousPicksList.remove(element); |
| if (previousPicksList.size() == MAXIMUM_NUMBER_OF_ELEMENTS) { |
| Object removedElement = previousPicksList.removeLast(); |
| ArrayList removedList = (ArrayList) textMap.remove(removedElement); |
| for (int i = 0; i < removedList.size(); i++) { |
| elementMap.remove(removedList.get(i)); |
| } |
| } |
| previousPicksList.addFirst(element); |
| |
| // textMap: |
| // Get list of strings for element from textMap |
| // Create new list for element if there isn't one and put |
| // element->textList in textMap |
| // Remove rememberedText from list |
| // If list is max size, remove first(oldest) string |
| // Remove text from elementMap |
| // Add rememberedText to list of strings for element in textMap |
| ArrayList textList = (ArrayList) textMap.get(element); |
| if (textList == null) { |
| textList = new ArrayList(); |
| textMap.put(element, textList); |
| } |
| |
| textList.remove(text); |
| if (textList.size() == MAXIMUM_NUMBER_OF_TEXT_ENTRIES_PER_ELEMENT) { |
| Object removedText = textList.remove(0); |
| elementMap.remove(removedText); |
| } |
| |
| if (text.length() > 0) { |
| textList.add(text); |
| |
| // elementMap: |
| // Put rememberedText->element in elementMap |
| // If it replaced a different element update textMap and |
| // PreviousPicksList |
| Object replacedElement = elementMap.put(text, element); |
| if (replacedElement != null && !replacedElement.equals(element)) { |
| textList = (ArrayList) textMap.get(replacedElement); |
| if (textList != null) { |
| textList.remove(text); |
| if (textList.isEmpty()) { |
| textMap.remove(replacedElement); |
| previousPicksList.remove(replacedElement); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * |
| */ |
| private void handleSelection() { |
| QuickAccessElement selectedElement = null; |
| String text = filterText.getText().toLowerCase(); |
| if (table.getSelectionCount() == 1) { |
| QuickAccessEntry entry = (QuickAccessEntry) table |
| .getSelection()[0].getData(); |
| selectedElement = entry == null ? null : entry.element; |
| } |
| close(); |
| if (selectedElement != null) { |
| handleElementSelected(text, selectedElement); |
| } |
| } |
| |
| private class PreviousPicksProvider extends QuickAccessProvider { |
| |
| public QuickAccessElement getElementForId(String id) { |
| return null; |
| } |
| |
| public QuickAccessElement[] getElements() { |
| return (QuickAccessElement[]) previousPicksList |
| .toArray(new QuickAccessElement[previousPicksList.size()]); |
| } |
| |
| public QuickAccessElement[] getElementsSorted() { |
| return getElements(); |
| } |
| |
| public String getId() { |
| return "org.eclipse.ui.previousPicks"; //$NON-NLS-1$ |
| } |
| |
| public ImageDescriptor getImageDescriptor() { |
| return WorkbenchImages |
| .getImageDescriptor(IWorkbenchGraphicConstants.IMG_OBJ_NODE); |
| } |
| |
| public String getName() { |
| return QuickAccessMessages.QuickAccess_Previous; |
| } |
| } |
| |
| } |