Java tutorial
/******************************************************************************* * Copyright (c) 2003, 2015 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.jface.action; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.ListIterator; import org.eclipse.core.runtime.Assert; import org.eclipse.jface.internal.provisional.action.IToolBarManager2; import org.eclipse.jface.util.Policy; import org.eclipse.swt.SWT; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.CoolBar; import org.eclipse.swt.widgets.CoolItem; import org.eclipse.swt.widgets.Menu; /** * A cool bar manager is a contribution manager which realizes itself and its * items in a cool bar control. * <p> * This class may be instantiated; it may also be subclassed. * </p> * * @since 3.0 */ public class CoolBarManager extends ContributionManager implements ICoolBarManager { /** * A separator created by the end user. */ public final static String USER_SEPARATOR = "UserSeparator"; //$NON-NLS-1$ /** * The original creation order of the contribution items. */ private ArrayList<IContributionItem> cbItemsCreationOrder = new ArrayList<>(); /** * MenuManager for cool bar pop-up menu, or null if none. */ private MenuManager contextMenuManager = null; /** * The cool bar control; <code>null</code> before creation and after * disposal. */ private CoolBar coolBar = null; /** * The cool bar items style; <code>SWT.NONE</code> by default. */ private int itemStyle = SWT.NONE; /** * Creates a new cool bar manager with the default style. Equivalent to * <code>CoolBarManager(SWT.NONE)</code>. */ public CoolBarManager() { // do nothing } /** * Creates a cool bar manager for an existing cool bar control. This * manager becomes responsible for the control, and will dispose of it when * the manager is disposed. * * @param coolBar * the cool bar control */ public CoolBarManager(CoolBar coolBar) { this(); Assert.isNotNull(coolBar); this.coolBar = coolBar; itemStyle = coolBar.getStyle(); } /** * Creates a cool bar manager with the given SWT style. Calling <code>createControl</code> * will create the cool bar control. * * @param style * the cool bar item style; see * {@link org.eclipse.swt.widgets.CoolBar CoolBar}for for valid * style bits */ public CoolBarManager(int style) { itemStyle = style; } @Override public void add(IToolBarManager toolBarManager) { Assert.isNotNull(toolBarManager); super.add(new ToolBarContributionItem(toolBarManager)); } /** * Collapses consecutive separators and removes a separator from the * beginning and end of the list. * * @param contributionList * the list of contributions; must not be <code>null</code>. * @return The contribution list provided with extraneous separators * removed; this value is never <code>null</code>, but may be * empty. */ private ArrayList<IContributionItem> adjustContributionList(ArrayList<IContributionItem> contributionList) { IContributionItem item; // Fist remove a separator if it is the first element of the list if (contributionList.size() != 0) { item = contributionList.get(0); if (item.isSeparator()) { contributionList.remove(0); } ListIterator<IContributionItem> iterator = contributionList.listIterator(); // collapse consecutive separators while (iterator.hasNext()) { item = iterator.next(); if (item.isSeparator()) { while (iterator.hasNext()) { item = iterator.next(); if (item.isSeparator()) { iterator.remove(); } else { break; } } } } if (contributionList.size() != 0) { // Now check last element to see if there is a separator item = contributionList.get(contributionList.size() - 1); if (item.isSeparator()) { contributionList.remove(contributionList.size() - 1); } } } return contributionList; } @Override protected boolean allowItem(IContributionItem itemToAdd) { /* We will allow as many null entries as they like, though there should * be none. */ if (itemToAdd == null) { return true; } /* Null identifiers can be expected in generic contribution items. */ String firstId = itemToAdd.getId(); if (firstId == null) { return true; } // Cycle through the current list looking for duplicates. IContributionItem[] currentItems = getItems(); for (int i = 0; i < currentItems.length; i++) { IContributionItem currentItem = currentItems[i]; // We ignore null entries. if (currentItem == null) { continue; } String secondId = currentItem.getId(); if (firstId.equals(secondId)) { if (Policy.TRACE_TOOLBAR) { System.out.println("Trying to add a duplicate item."); //$NON-NLS-1$ new Exception().printStackTrace(System.out); System.out.println("DONE --------------------------"); //$NON-NLS-1$ } return false; } } return true; } /** * Positions the list iterator to the end of all the separators. Calling * <code>next()</code> the iterator should return the immediate object * following the last separator. * * @param iterator * the list iterator. */ private void collapseSeparators(ListIterator<IContributionItem> iterator) { while (iterator.hasNext()) { IContributionItem item = iterator.next(); if (!item.isSeparator()) { iterator.previous(); return; } } } /** * Returns whether the cool bar control has been created and not yet * disposed. * * @return <code>true</code> if the control has been created and not yet * disposed, <code>false</code> otherwise */ private boolean coolBarExist() { return coolBar != null && !coolBar.isDisposed(); } /** * Creates and returns this manager's cool bar control. Does not create a * new control if one already exists. * * @param parent * the parent control * @return the cool bar control */ public CoolBar createControl(Composite parent) { Assert.isNotNull(parent); if (!coolBarExist()) { coolBar = new CoolBar(parent, itemStyle); coolBar.setMenu(getContextMenuControl()); coolBar.setLocked(false); update(false); } return coolBar; } /** * Disposes of this cool bar manager and frees all allocated SWT resources. * Notifies all contribution items of the dispose. Note that this method * does not clean up references between this cool bar manager and its * associated contribution items. Use <code>removeAll</code> for that * purpose. */ public void dispose() { if (coolBarExist()) { coolBar.dispose(); coolBar = null; } IContributionItem[] items = getItems(); for (int i = 0; i < items.length; i++) { // Disposes of the contribution item. // If Contribution Item is a toolbar then it will dispose of // all the nested // contribution items. items[i].dispose(); } // If a context menu existed then dispose of it. if (contextMenuManager != null) { contextMenuManager.dispose(); contextMenuManager = null; } } /** * Disposes the given cool item. * * @param item * the cool item to dispose */ private void dispose(CoolItem item) { if ((item != null) && !item.isDisposed()) { item.setData(null); Control control = item.getControl(); // if the control is already disposed, setting the coolitem // control to null will cause an SWT exception, workaround // for 19630 if ((control != null) && !control.isDisposed()) { item.setControl(null); // we created it, we dispose it, see bug 293433 control.dispose(); } item.dispose(); } } /** * Finds the cool item associated with the given contribution item. * * @param item * the contribution item * @return the associated cool item, or <code>null</code> if not found */ private CoolItem findCoolItem(IContributionItem item) { CoolItem[] coolItems = (coolBar == null) ? null : coolBar.getItems(); return findCoolItem(coolItems, item); } private CoolItem findCoolItem(CoolItem[] items, IContributionItem item) { if (items == null) { return null; } for (int i = 0; i < items.length; i++) { CoolItem coolItem = items[i]; IContributionItem data = (IContributionItem) coolItem.getData(); if (data != null && data.equals(item)) { return coolItem; } } return null; } /** * Return a consistent set of wrap indices. The return value will always * include at least one entry and the first entry will always be zero. * CoolBar.getWrapIndices() is inconsistent in whether or not it returns an * index for the first row. * * @param wraps * the wrap indicies from the cool bar widget * @return the adjusted wrap indicies. */ private int[] getAdjustedWrapIndices(int[] wraps) { int[] adjustedWrapIndices; if (wraps.length == 0) { adjustedWrapIndices = new int[] { 0 }; } else { if (wraps[0] != 0) { adjustedWrapIndices = new int[wraps.length + 1]; adjustedWrapIndices[0] = 0; for (int i = 0; i < wraps.length; i++) { adjustedWrapIndices[i + 1] = wraps[i]; } } else { adjustedWrapIndices = wraps; } } return adjustedWrapIndices; } /** * Returns the control of the Menu Manager. If the menu manager does not * have a control then one is created. * * @return menu control associated with manager, or null if none */ private Menu getContextMenuControl() { if ((contextMenuManager != null) && (coolBar != null)) { Menu menuWidget = contextMenuManager.getMenu(); if ((menuWidget == null) || (menuWidget.isDisposed())) { menuWidget = contextMenuManager.createContextMenu(coolBar); } return menuWidget; } return null; } @Override public IMenuManager getContextMenuManager() { return contextMenuManager; } /** * Returns the cool bar control for this manager. * * @return the cool bar control, or <code>null</code> if none */ public CoolBar getControl() { return coolBar; } /** * Returns an array list of all the contribution items in the manager. * * @return an array list of contribution items. */ private ArrayList<IContributionItem> getItemList() { IContributionItem[] cbItems = getItems(); ArrayList<IContributionItem> list = new ArrayList<>(cbItems.length); for (int i = 0; i < cbItems.length; i++) { list.add(cbItems[i]); } return list; } @Override public boolean getLockLayout() { if (!coolBarExist()) { return false; } return coolBar.getLocked(); } /** * Returns the number of rows that should be displayed visually. * * @param items * the array of contributin items * @return the number of rows */ private int getNumRows(IContributionItem[] items) { int numRows = 1; boolean separatorFound = false; for (int i = 0; i < items.length; i++) { if (items[i].isSeparator()) { separatorFound = true; } if ((separatorFound) && (isChildVisible(items[i])) && (!items[i].isGroupMarker()) && (!items[i].isSeparator())) { numRows++; separatorFound = false; } } return numRows; } @Override public int getStyle() { return itemStyle; } /** * Subclasses may extend this <code>ContributionManager</code> method, * but must call <code>super.itemAdded</code>. * * @see org.eclipse.jface.action.ContributionManager#itemAdded(org.eclipse.jface.action.IContributionItem) */ @Override protected void itemAdded(IContributionItem item) { Assert.isNotNull(item); super.itemAdded(item); int insertedAt = indexOf(item); boolean replaced = false; final int size = cbItemsCreationOrder.size(); for (int i = 0; i < size; i++) { IContributionItem created = cbItemsCreationOrder.get(i); if (created.getId() != null && created.getId().equals(item.getId())) { cbItemsCreationOrder.set(i, item); replaced = true; break; } } if (!replaced) { cbItemsCreationOrder.add(Math.min(Math.max(insertedAt, 0), cbItemsCreationOrder.size()), item); } } /** * Subclasses may extend this <code>ContributionManager</code> method, * but must call <code>super.itemRemoved</code>. * * @see org.eclipse.jface.action.ContributionManager#itemRemoved(org.eclipse.jface.action.IContributionItem) */ @Override protected void itemRemoved(IContributionItem item) { Assert.isNotNull(item); super.itemRemoved(item); CoolItem coolItem = findCoolItem(item); if (coolItem != null) { coolItem.setData(null); } } /** * Positions the list iterator to the starting of the next row. By calling * next on the returned iterator, it will return the first element of the * next row. * * @param iterator * the list iterator of contribution items * @param ignoreCurrentItem * Whether the current item in the iterator should be considered * (as well as subsequent items). */ private void nextRow(ListIterator<IContributionItem> iterator, boolean ignoreCurrentItem) { IContributionItem currentElement = null; if (!ignoreCurrentItem && iterator.hasPrevious()) { currentElement = iterator.previous(); iterator.next(); } if ((currentElement != null) && (currentElement.isSeparator())) { collapseSeparators(iterator); return; } //Find next separator while (iterator.hasNext()) { IContributionItem item = iterator.next(); if (item.isSeparator()) { // we we find a separator, collapse any consecutive // separators // and return collapseSeparators(iterator); return; } } } /* * Used for debuging. Prints all the items in the internal structures. */ // private void printContributions(ArrayList contributionList) { // int index = 0; // System.out.println("----------------------------------\n"); //$NON-NLS-1$ // for (Iterator i = contributionList.iterator(); i.hasNext(); index++) { // IContributionItem item = (IContributionItem) i.next(); // if (item.isSeparator()) { // System.out.println("Separator"); //$NON-NLS-1$ // } else { // System.out.println(index + ". Item id: " + item.getId() //$NON-NLS-1$ // + " - is Visible: " //$NON-NLS-1$ // + item.isVisible()); // } // } // } /** * Synchronizes the visual order of the cool items in the control with this * manager's internal data structures. This method should be called before * requesting the order of the contribution items to ensure that the order * is accurate. * <p> * Note that <code>update()</code> and <code>refresh()</code> are * converses: <code>update()</code> changes the visual order to match the * internal structures, and <code>refresh</code> changes the internal * structures to match the visual order. * </p> */ public void refresh() { if (!coolBarExist()) { return; } // Retreives the list of contribution items as an array list ArrayList<IContributionItem> contributionList = getItemList(); // Check the size of the list if (contributionList.size() == 0) { return; } // The list of all the cool items in their visual order CoolItem[] coolItems = coolBar.getItems(); // The wrap indicies of the coolbar int[] wrapIndicies = getAdjustedWrapIndices(coolBar.getWrapIndices()); int row = 0; int coolItemIndex = 0; // Traverse through all cool items in the coolbar add them to a new // data structure // in the correct order ArrayList<IContributionItem> displayedItems = new ArrayList<>(coolBar.getItemCount()); for (int i = 0; i < coolItems.length; i++) { CoolItem coolItem = coolItems[i]; if (coolItem.getData() instanceof IContributionItem) { IContributionItem cbItem = (IContributionItem) coolItem.getData(); displayedItems.add(Math.min(i, displayedItems.size()), cbItem); } } // Add separators to the displayed Items data structure int offset = 0; for (int i = 1; i < wrapIndicies.length; i++) { int insertAt = wrapIndicies[i] + offset; displayedItems.add(insertAt, new Separator(USER_SEPARATOR)); offset++; } // Determine which rows are invisible ArrayList<Integer> existingVisibleRows = new ArrayList<>(4); ListIterator<IContributionItem> rowIterator = contributionList.listIterator(); collapseSeparators(rowIterator); int numRow = 0; while (rowIterator.hasNext()) { // Scan row while (rowIterator.hasNext()) { IContributionItem cbItem = rowIterator.next(); if (displayedItems.contains(cbItem)) { existingVisibleRows.add(Integer.valueOf(numRow)); break; } if (cbItem.isSeparator()) { break; } } nextRow(rowIterator, false); numRow++; } Iterator<Integer> existingRows = existingVisibleRows.iterator(); // Adjust row number to the first visible if (existingRows.hasNext()) { row = existingRows.next().intValue(); } HashMap<IContributionItem, Integer> itemLocation = new HashMap<>(); for (ListIterator<IContributionItem> locationIterator = displayedItems.listIterator(); locationIterator .hasNext();) { IContributionItem item = locationIterator.next(); if (item.isSeparator()) { if (existingRows.hasNext()) { Integer value = existingRows.next(); row = value.intValue(); } else { row++; } } else { itemLocation.put(item, Integer.valueOf(row)); } } // Insert the contribution items in their correct location for (ListIterator<IContributionItem> iterator = displayedItems.listIterator(); iterator.hasNext();) { IContributionItem cbItem = iterator.next(); if (cbItem.isSeparator()) { coolItemIndex = 0; } else { relocate(cbItem, coolItemIndex, contributionList, itemLocation); cbItem.saveWidgetState(); coolItemIndex++; } } contributionList = adjustContributionList(contributionList); if (contributionList.size() != 0) { IContributionItem[] array = new IContributionItem[contributionList.size() - 1]; array = contributionList.toArray(array); internalSetItems(array); } } /** * Relocates the given contribution item to the specified index. * * @param cbItem * the conribution item to relocate * @param index * the index to locate this item * @param contributionList * the current list of conrtributions * @param itemLocation */ private void relocate(IContributionItem cbItem, int index, ArrayList<IContributionItem> contributionList, HashMap<IContributionItem, Integer> itemLocation) { if ((itemLocation.get(cbItem) == null)) { return; } int targetRow = itemLocation.get(cbItem).intValue(); int cbInternalIndex = contributionList.indexOf(cbItem); // by default add to end of list int insertAt = contributionList.size(); // Find the row to place this item in. ListIterator<IContributionItem> iterator = contributionList.listIterator(); // bypass any separators at the begining collapseSeparators(iterator); int currentRow = -1; while (iterator.hasNext()) { currentRow++; if (currentRow == targetRow) { // We found the row to insert the item int virtualIndex = 0; insertAt = iterator.nextIndex(); // first check the position of the current element (item) // then get the next element while (iterator.hasNext()) { IContributionItem item = iterator.next(); Integer itemRow = itemLocation.get(item); if (item.isSeparator()) { break; } // if the item has an associate widget if ((itemRow != null) && (itemRow.intValue() == targetRow)) { // if the next element is the index we are looking for // then break if (virtualIndex >= index) { break; } virtualIndex++; } insertAt++; } // If we don't need to move it then we return if (cbInternalIndex == insertAt) { return; } break; } nextRow(iterator, true); } contributionList.remove(cbItem); // Adjust insertAt index if (cbInternalIndex < insertAt) { insertAt--; } // if we didn't find the row then add a new row if (currentRow != targetRow) { contributionList.add(new Separator(USER_SEPARATOR)); insertAt = contributionList.size(); } insertAt = Math.min(insertAt, contributionList.size()); contributionList.add(insertAt, cbItem); } /** * Restores the canonical order of this cool bar manager. The canonical * order is the order in which the contribution items where added. */ public void resetItemOrder() { for (ListIterator<IContributionItem> iterator = cbItemsCreationOrder.listIterator(); iterator.hasNext();) { IContributionItem item = iterator.next(); // if its a user separator then do not include in original order. if ((item.getId() != null) && (item.getId().equals(USER_SEPARATOR))) { iterator.remove(); } } IContributionItem[] itemsToSet = new IContributionItem[cbItemsCreationOrder.size()]; cbItemsCreationOrder.toArray(itemsToSet); setItems(itemsToSet); } @Override public void setContextMenuManager(IMenuManager contextMenuManager) { this.contextMenuManager = (MenuManager) contextMenuManager; if (coolBar != null) { coolBar.setMenu(getContextMenuControl()); } } /** * Replaces the current items with the given items. * Forces an update. * * @param newItems the items with which to replace the current items */ public void setItems(IContributionItem[] newItems) { // dispose of all the cool items on the cool bar manager if (coolBar != null) { CoolItem[] coolItems = coolBar.getItems(); for (int i = 0; i < coolItems.length; i++) { dispose(coolItems[i]); } } // Set the internal structure to this order internalSetItems(newItems); // Force and update update(true); } @Override public void setLockLayout(boolean value) { if (!coolBarExist()) { return; } coolBar.setLocked(value); } /** * Subclasses may extend this <code>IContributionManager</code> method, * but must call <code>super.update</code>. * * @see org.eclipse.jface.action.IContributionManager#update(boolean) */ @Override public void update(boolean force) { if ((!isDirty() && !force) || (!coolBarExist())) { return; } boolean relock = false; boolean changed = false; try { coolBar.setRedraw(false); // Refresh the widget data with the internal data structure. refresh(); if (coolBar.getLocked()) { coolBar.setLocked(false); relock = true; } /* * Make a list of items including only those items that are * visible. Separators should stay because they mark line breaks in * a cool bar. */ final IContributionItem[] items = getItems(); final List<IContributionItem> visibleItems = new ArrayList<>(items.length); for (int i = 0; i < items.length; i++) { final IContributionItem item = items[i]; if (isChildVisible(item)) { visibleItems.add(item); } } /* * Make a list of CoolItem widgets in the cool bar for which there * is no current visible contribution item. These are the widgets * to be disposed. Dynamic items are also removed. */ CoolItem[] coolItems = coolBar.getItems(); final ArrayList<CoolItem> coolItemsToRemove = new ArrayList<>(coolItems.length); for (int i = 0; i < coolItems.length; i++) { final Object data = coolItems[i].getData(); if ((data == null) || (!visibleItems.contains(data)) || ((data instanceof IContributionItem) && ((IContributionItem) data).isDynamic())) { coolItemsToRemove.add(coolItems[i]); } } // Dispose of any items in the list to be removed. for (int i = coolItemsToRemove.size() - 1; i >= 0; i--) { CoolItem coolItem = coolItemsToRemove.get(i); if (!coolItem.isDisposed()) { Control control = coolItem.getControl(); if (control != null) { coolItem.setControl(null); control.dispose(); } coolItem.dispose(); } } // Add any new items by telling them to fill. coolItems = coolBar.getItems(); IContributionItem sourceItem; IContributionItem destinationItem; int sourceIndex = 0; int destinationIndex = 0; final Iterator<IContributionItem> visibleItemItr = visibleItems.iterator(); while (visibleItemItr.hasNext()) { sourceItem = visibleItemItr.next(); // Retrieve the corresponding contribution item from SWT's // data. if (sourceIndex < coolItems.length) { destinationItem = (IContributionItem) coolItems[sourceIndex].getData(); } else { destinationItem = null; } // The items match is they are equal or both separators. if (destinationItem != null) { if (sourceItem.equals(destinationItem)) { sourceIndex++; destinationIndex++; sourceItem.update(); continue; } else if ((destinationItem.isSeparator()) && (sourceItem.isSeparator())) { coolItems[sourceIndex].setData(sourceItem); sourceIndex++; destinationIndex++; sourceItem.update(); continue; } } // Otherwise, a new item has to be added. final int start = coolBar.getItemCount(); if (sourceItem instanceof ToolBarContributionItem) { IToolBarManager manager = ((ToolBarContributionItem) sourceItem).getToolBarManager(); if (manager instanceof IToolBarManager2) { ((IToolBarManager2) manager).setOverrides(getOverrides()); } } sourceItem.fill(coolBar, destinationIndex); final int newItems = coolBar.getItemCount() - start; for (int i = 0; i < newItems; i++) { coolBar.getItem(destinationIndex++).setData(sourceItem); } changed = true; } // Remove any old widgets not accounted for. for (int i = coolItems.length - 1; i >= sourceIndex; i--) { final CoolItem item = coolItems[i]; if (!item.isDisposed()) { Control control = item.getControl(); if (control != null) { item.setControl(null); control.dispose(); } item.dispose(); changed = true; } } // Update wrap indices. updateWrapIndices(); // Update the sizes. for (int i = 0; i < items.length; i++) { IContributionItem item = items[i]; item.update(SIZE); } // if the coolBar was previously locked then lock it if (relock) { coolBar.setLocked(true); } if (changed) { updateTabOrder(); } // We are no longer dirty. setDirty(false); } finally { coolBar.setRedraw(true); } } /** * Sets the tab order of the coolbar to the visual order of its items. */ /* package */void updateTabOrder() { if (coolBar != null) { CoolItem[] items = coolBar.getItems(); if (items != null) { ArrayList<Control> children = new ArrayList<>(items.length); for (int i = 0; i < items.length; i++) { if ((items[i].getControl() != null) && (!items[i].getControl().isDisposed())) { children.add(items[i].getControl()); } } // Convert array Control[] childrenArray = new Control[0]; childrenArray = children.toArray(childrenArray); if (childrenArray != null) { coolBar.setTabList(childrenArray); } } } } /** * Updates the indices at which the cool bar should wrap. */ private void updateWrapIndices() { final IContributionItem[] items = getItems(); final int numRows = getNumRows(items) - 1; // Generate the list of wrap indices. final int[] wrapIndices = new int[numRows]; boolean foundSeparator = false; int j = 0; CoolItem[] coolItems = (coolBar == null) ? null : coolBar.getItems(); for (int i = 0; i < items.length; i++) { IContributionItem item = items[i]; CoolItem coolItem = findCoolItem(coolItems, item); if (item.isSeparator()) { foundSeparator = true; } if ((!item.isSeparator()) && (!item.isGroupMarker()) && (isChildVisible(item)) && (coolItem != null) && (foundSeparator)) { wrapIndices[j] = coolBar.indexOf(coolItem); j++; foundSeparator = false; } } /* * Check to see if these new wrap indices are different than the old * ones. */ final int[] oldIndices = coolBar.getWrapIndices(); boolean shouldUpdate = false; if (oldIndices.length == wrapIndices.length) { for (int i = 0; i < oldIndices.length; i++) { if (oldIndices[i] != wrapIndices[i]) { shouldUpdate = true; break; } } } else { shouldUpdate = true; } if (shouldUpdate) { coolBar.setWrapIndices(wrapIndices); } } private boolean isChildVisible(IContributionItem item) { Boolean v; IContributionManagerOverrides overrides = getOverrides(); if (overrides == null) { v = null; } else { v = getOverrides().getVisible(item); } if (v != null) { return v.booleanValue(); } return item.isVisible(); } }