import org.eclipse.jface.dialogs.PopupDialog;

		PopupDialog popupDialog = new QuickAccessDialog(window, providers);

		popupDialog.open();

		if(true) return null;

import java.util.StringTokenizer;

	 * @return a string containing the first character of every word for

	 * camel case checking.

	 */

	private static String getCamelCase(String label) {

		StringTokenizer tokenizer = new StringTokenizer(label);

		StringBuffer camelCase = new StringBuffer();

		while(tokenizer.hasMoreTokens()) {

			String word = tokenizer.nextToken();

			camelCase.append(word.charAt(0));

		}

		return camelCase.toString();

	}

	final String[] getMatchLabels() {

		String sortLabel = getSortLabel();

		String camelCase = getCamelCase(sortLabel);

		String combinedLabel = provider.getName()

				+ " " + getLabel(); //$NON-NLS-1$

		String combinedCamelCase = getCamelCase(combinedLabel);

		return (new String[] { sortLabel, camelCase, combinedLabel, combinedCamelCase });

	}

	/**

import java.util.Arrays;

import java.util.Comparator;

	private AbstractElement[] sortedElements;

	public AbstractElement[] getElementsSorted() {

		if (sortedElements == null) {

			sortedElements = getElements();

			Arrays.sort(sortedElements, new Comparator() {

				public int compare(Object o1, Object o2) {

					AbstractElement e1 = (AbstractElement) o1;

					AbstractElement e2 = (AbstractElement) o2;

					return e1.getLabel().compareTo(e2.getLabel());

				}

			});

		}

		return sortedElements;

	}

package org.eclipse.ui.internal.incubator;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.LinkedList;

import java.util.Map;

import org.eclipse.core.runtime.Assert;

import org.eclipse.jface.dialogs.Dialog;

import org.eclipse.jface.dialogs.IDialogSettings;

import org.eclipse.jface.dialogs.PopupDialog;

import org.eclipse.jface.layout.GridDataFactory;

import org.eclipse.jface.layout.TableColumnLayout;

import org.eclipse.jface.resource.DeviceResourceException;

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.swt.SWT;

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.graphics.Color;

import org.eclipse.swt.graphics.Font;

import org.eclipse.swt.graphics.FontMetrics;

import org.eclipse.swt.graphics.GC;

import org.eclipse.swt.graphics.Image;

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.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.misc.StringMatcher;

import org.eclipse.ui.internal.progress.ProgressManagerUtil;

/**

 * @since 3.3

 * 

 */

public class QuickAccessDialog extends PopupDialog {

	private static final int MAX_COUNT_PER_PROVIDER = 5;

	private static final int MAX_COUNT_TOTAL = 20;

	private Text filterText;

	private AbstractProvider[] 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;

	/**

	 * @param parent

	 * @param providers

	 */

	QuickAccessDialog(IWorkbenchWindow window, AbstractProvider[] providers) {

		super(ProgressManagerUtil.getDefaultParent(), SWT.RESIZE, true, true,

				true, true, "Foo", "boo"); //$NON-NLS-1$ //$NON-NLS-2$

		this.window = window;

		this.providers = providers;

		providers[0] = new PreviousPicksProvider();

		providerMap = new HashMap();

		for (int i = 0; i < providers.length; i++) {

			providerMap.put(providers[i].getId(), providers[i]);

		}

		restoreDialog();

	}

	protected Control createTitleControl(Composite parent) {

		filterText = new Text(parent, SWT.NONE);

		GC gc = new GC(parent);

		gc.setFont(parent.getFont());

		FontMetrics fontMetrics = gc.getFontMetrics();

		gc.dispose();

		GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER).grab(true,

				false).hint(SWT.DEFAULT,

				Dialog.convertHeightInCharsToPixels(fontMetrics, 1)).applyTo(

				filterText);

		filterText.addKeyListener(new KeyListener() {

			public void keyPressed(KeyEvent e) {

				if (e.keyCode == 0x0D) {

					AbstractElement selectedElement = null;

					if (table.getSelectionCount() == 1) {

						selectedElement = ((TableEntry) table.getSelection()[0]

								.getData()).element;

					}

					close();

					if (selectedElement != null) {

						handleElementSelected(selectedElement);

					}

				}

				if (e.keyCode == SWT.ARROW_DOWN)

					table.setFocus();

					if (table.getItemCount() > 1) {

						table.setSelection(1);

					}

				if (e.keyCode == SWT.ARROW_UP)

					table.setFocus();

				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();

				int length = text.length();

				if (length > 0) {

					if (text.charAt(length - 1) != '*') {

						text = text + '*';

					}

					if (text.charAt(0) != '*') {

						text = '*' + text;

					}

				}

				refreshTable(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);

		TableColumnLayout tableColumnLayout = new TableColumnLayout();

		composite.setLayout(tableColumnLayout);

		table = new Table(composite, SWT.SINGLE | SWT.H_SCROLL | SWT.V_SCROLL

				| SWT.FULL_SELECTION);

		tableColumnLayout.setColumnData(new TableColumn(table, SWT.NONE),

				new ColumnWeightData(0, 120));

		tableColumnLayout.setColumnData(new TableColumn(table, SWT.NONE),

				new ColumnWeightData(100, 100));

		// table.addListener(SWT.MeasureItem, new Listener() {

		// public void handleEvent(Event event) {

		// TableEntry entry = (TableEntry) event.item.getData();

		// }

		// });

		// TextLayout layout = new TextLayout(table.getDisplay());

		final TextLayout textLayout = new TextLayout(table.getDisplay());

		Font boldFont = resourceManager.createFont(FontDescriptor.createFrom(table.getFont()).setStyle(SWT.BOLD));

		final TextStyle boldStyle = new TextStyle(boldFont, null, null);

		Listener listener = new Listener() {

			public void handleEvent(Event event) {

				Color oldForeground = event.gc.getForeground();

				TableEntry entry = (TableEntry) event.item.getData();

				switch (event.type) {

				case SWT.MeasureItem:

					switch (event.index) {

					case 0:

						if (entry.firstInCategory) {

							textLayout.setText(entry.provider.getName());

						}

						break;

					case 1:

						Image image = getImage(entry.element);

						Rectangle imageRect = image.getBounds();

						event.width += imageRect.width + 2;

						event.height = Math.max(event.height, imageRect.height + 2);

						textLayout.setText(entry.element.getLabel());

						String filter = filterText.getText();

						int filterIndex = entry.element.getLabel().indexOf(filter);

						if (filterIndex != -1) {

							textLayout.setStyle(boldStyle, filterIndex, filterIndex + filter.length() - 1);

						}

						break;

					}

					Rectangle rect = textLayout.getBounds();

					event.width += rect.width;

					event.height = Math.max(event.height, rect.height + 2);

					break;

				case SWT.PaintItem:

					boolean selected  = (event.detail & SWT.SELECTED) != 0;

					boolean hasFocus = table.isFocusControl();

					event.gc.setForeground(table

							.getDisplay()

							.getSystemColor(

									hasFocus && selected ? SWT.COLOR_LIST_SELECTION_TEXT

											: SWT.COLOR_LIST_FOREGROUND));

					switch (event.index) {

					case 0:

						if (entry.firstInCategory) {

							textLayout.setText(entry.provider.getName());

							textLayout.draw(event.gc, event.x+1, event.y+1);

						}

						break;

					case 1:

						Image image = getImage(entry.element);

						event.gc.drawImage(image, event.x + 1, event.y + 1);

						textLayout.setText(entry.element.getLabel());

						String filter = filterText.getText();

						int filterIndex = entry.element.getLabel().toLowerCase().indexOf(filter.toLowerCase());

						if (filterIndex != -1) {

							textLayout.setStyle(boldStyle, filterIndex, filterIndex + filter.length() - 1);

						}

						textLayout.draw(event.gc, event.x+3+image.getBounds().width, event.y+2);

						break;

					}

					if (entry.lastInCategory) {

						event.gc.setForeground(event.item.getDisplay()

								.getSystemColor(SWT.COLOR_GRAY));

						int x = event.x;

						if (event.index == 0) {

							x = 0;

						}

						event.gc.drawLine(x, event.y + event.height - 1, x

								+ ((TableItem) event.item).getParent()

										.getColumn(event.index).getWidth(),

								event.y + event.height - 1);

					}

					event.gc.setForeground(oldForeground);

					break;

				case SWT.EraseItem:

					Rectangle bounds = event.getBounds();

					if ((event.detail & SWT.SELECTED) != 0) {

						Color oldBackground = event.gc.getBackground();

						final int background = table.isFocusControl() ? SWT.COLOR_LIST_SELECTION

								: SWT.COLOR_WIDGET_BACKGROUND;

						event.gc.setBackground(event.item.getDisplay()

								.getSystemColor(background));

						event.gc.setForeground(event.item.getDisplay()

								.getSystemColor(SWT.COLOR_LIST_SELECTION_TEXT));

						event.gc.fillRectangle(bounds);

						/* restore the old GC colors */

						event.gc.setForeground(oldForeground);

						event.gc.setBackground(oldBackground);

						/* ensure that default selection is not drawn */

						event.detail &= ~SWT.SELECTED;

					}

					break;

				}

			}

		};

		table.addListener(SWT.MeasureItem, listener);

		table.addListener(SWT.EraseItem, listener);

		table.addListener(SWT.PaintItem, listener);

		refreshTable(""); //$NON-NLS-1$

		return composite;

	}

	private static class TableEntry {

		boolean firstInCategory;

		boolean lastInCategory;

		AbstractElement element;

		AbstractProvider provider;

		TableEntry(boolean firstInCategory, AbstractElement element,

				AbstractProvider provider) {

			this.firstInCategory = firstInCategory;

			this.element = element;

			this.provider = provider;

		}

	}

	/**

	 * 

	 */

	private void refreshTable(String filter) {

		TableItem[] items = table.getItems();

		StringMatcher stringMatcher = new StringMatcher(filter, true, false);

		int countTotal = 0;

		TableEntry lastEntry = null;

		for (int i = 0; i < providers.length && countTotal < MAX_COUNT_TOTAL; i++) {

			int countPerProvider = 0;

			AbstractProvider provider = providers[i];

			if (filter.length() > 0

					|| provider instanceof PreviousPicksProvider) {

				AbstractElement[] elements = provider.getElementsSorted();

				element_loop: for (int j = 0; j < elements.length

						&& countPerProvider < MAX_COUNT_PER_PROVIDER

						&& countTotal < MAX_COUNT_TOTAL; j++) {

					AbstractElement element = elements[j];

					String[] matchLabels = element.getMatchLabels();

					for (int k = 0; k < matchLabels.length; k++) {

						if (stringMatcher.match(matchLabels[k])

								|| filter.length() == 0) {

							boolean firstInCategory = countPerProvider == 0;

							if (firstInCategory && lastEntry!=null) {

								lastEntry.lastInCategory = true;

							}

							TableEntry entry = new TableEntry(firstInCategory,

									element, provider);

							lastEntry = entry;

							TableItem item;

							if (countTotal < items.length) {

								item = items[countTotal];

							} else {

								item = new TableItem(table, SWT.NONE);

							}

							item.setData(entry);

//							if (firstInCategory) {

//								item.setText(0, provider.getName());

//							} else {

//								item.setText(0, ""); //$NON-NLS-1$

//							}

//							item.setText(1, element.getLabel());

//							item.setImage(1, getImage(element));

							countPerProvider++;

							countTotal++;

							continue element_loop;

						}

					}

				}

			}

		}

		if (lastEntry!=null) {

			lastEntry.lastInCategory = true;

		}

		if (countTotal < items.length) {

			table.remove(countTotal, items.length - 1);

		}

		if (countTotal > 0) {

			table.setSelection(0);

		} else {

			table.deselectAll();

		}

	}

	Image getImage(AbstractElement element) {

		Image image = findOrCreateImage(element.getImageDescriptor());

		if (image == null) {

			image = WorkbenchImages

					.getImage(IWorkbenchGraphicConstants.IMG_OBJ_ELEMENT);

		}

		return image;

	}

	private Image findOrCreateImage(ImageDescriptor imageDescriptor) {

		if (imageDescriptor == null) {

			return null;

		}

		Image image = (Image) resourceManager.find(imageDescriptor);

		if (image == null) {

			try {

				image = resourceManager.createImage(imageDescriptor);

			} catch (DeviceResourceException e) {

				WorkbenchPlugin.log(e);

			}

		}

		return image;

	}

	protected Control getFocusControl() {

		return filterText;

	}

	public boolean close() {

		storeDialog(getDialogSettings());

		if (resourceManager != null) {

			resourceManager.dispose();

			resourceManager = null;

		}

		return super.close();

	}

	protected Point getInitialSize() {

		if (!getPersistBounds()) {

			return new Point(400, 400);

		}

		return super.getInitialSize();

	}

	protected Point getInitialLocation(Point initialSize) {

		if (!getPersistBounds()) {

			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);

		}

		return super.getInitialLocation(initialSize);

	}

	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++) {

			AbstractElement abstractElement = (AbstractElement) previousPicksList

					.get(i);

			ArrayList elementText = (ArrayList) textMap.get(abstractElement);

			Assert.isNotNull(elementText);

			orderedElements[i] = abstractElement.getId();

			orderedProviders[i] = abstractElement.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++) {

					AbstractProvider abstractProvider = (AbstractProvider) providerMap

							.get(orderedProviders[i]);

					int numTexts = Integer.parseInt(textEntries[i]);

					if (abstractProvider != null) {

						AbstractElement abstractElement = abstractProvider

								.getElementForId(orderedElements[i]);

						if (abstractElement != null) {

							ArrayList arrayList = new ArrayList();

							for (int j = arrayIndex; j < arrayIndex + numTexts; j++) {

								arrayList.add(textArray[j]);

								elementMap.put(textArray[j], abstractElement);

							}

							textMap.put(abstractElement, arrayList);

							previousPicksList.add(abstractElement);

						}

					}

					arrayIndex += numTexts;

				}

			}

		}

	}

	protected void handleElementSelected(Object selectedElement) {

		IWorkbenchPage activePage = window.getActivePage();

		if (activePage != null) {

			if (selectedElement instanceof AbstractElement) {

				addPreviousPick(selectedElement);

				storeDialog(getDialogSettings());

				AbstractElement element = (AbstractElement) selectedElement;

				element.execute();

			}

		}

	}

	/**

	 * @param element

	 */

	private void addPreviousPick(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(rememberedText);

		if (textList.size() == MAXIMUM_NUMBER_OF_TEXT_ENTRIES_PER_ELEMENT) {

			Object removedText = textList.remove(0);

			elementMap.remove(removedText);

		}

		textList.add(rememberedText);

		// elementMap:

		// Put rememberedText->element in elementMap

		// If it replaced a different element update textMap and

		// PreviousPicksList

		Object replacedElement = elementMap.put(rememberedText, element);

		if (replacedElement != null && !replacedElement.equals(element)) {

			textList = (ArrayList) textMap.get(replacedElement);

			if (textList != null) {

				textList.remove(rememberedText);

				if (textList.isEmpty()) {

					textMap.remove(replacedElement);

					previousPicksList.remove(replacedElement);

				}

			}

		}

	}

	private class PreviousPicksProvider extends AbstractProvider {

		public AbstractElement getElementForId(String id) {

			return null;

		}

		public AbstractElement[] getElements() {

			return (AbstractElement[]) previousPicksList

					.toArray(new AbstractElement[previousPicksList.size()]);

		}

		public AbstractElement[] 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 IncubatorMessages.CtrlEAction_Previous;

		}

	}

}