| /******************************************************************************* |
| * Copyright (c) 2005, 2007 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 |
| * Stefan Xenos, IBM - bug 51580 |
| * Chris Torrence, ITT Visual Information Solutions - bugs 51580 202208 |
| *******************************************************************************/ |
| package org.eclipse.ui.internal.presentations.util; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.Map; |
| |
| import org.eclipse.core.runtime.Assert; |
| import org.eclipse.core.runtime.Plugin; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.DisposeEvent; |
| import org.eclipse.swt.events.DisposeListener; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.ui.IMemento; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.internal.preferences.IDynamicPropertyMap; |
| import org.eclipse.ui.internal.preferences.PreferenceStoreAdapter; |
| import org.eclipse.ui.internal.preferences.PreferencesAdapter; |
| import org.eclipse.ui.internal.preferences.PropertyMapAdapter; |
| import org.eclipse.ui.internal.preferences.ThemeManagerAdapter; |
| import org.eclipse.ui.internal.presentations.defaultpresentation.DefaultPartList; |
| import org.eclipse.ui.internal.util.PrefUtil; |
| import org.eclipse.ui.presentations.IPartMenu; |
| import org.eclipse.ui.presentations.IPresentablePart; |
| import org.eclipse.ui.presentations.IPresentationSerializer; |
| import org.eclipse.ui.presentations.IStackPresentationSite; |
| import org.eclipse.ui.presentations.StackDropResult; |
| import org.eclipse.ui.presentations.StackPresentation; |
| |
| /** |
| * @since 3.0 |
| */ |
| public final class TabbedStackPresentation extends StackPresentation { |
| |
| private PresentablePartFolder folder; |
| private ISystemMenu systemMenu; |
| private ISystemMenu partList; |
| private PreferenceStoreAdapter apiPreferences = new PreferenceStoreAdapter(PrefUtil |
| .getAPIPreferenceStore()); |
| private ThemeManagerAdapter themePreferences = new ThemeManagerAdapter( |
| PlatformUI.getWorkbench().getThemeManager()); |
| |
| private TabOrder tabs; |
| |
| private TabDragHandler dragBehavior; |
| |
| private boolean initializing = true; |
| private int ignoreSelectionChanges = 0; |
| |
| private TabFolderListener tabFolderListener = new TabFolderListener() { |
| public void handleEvent(TabFolderEvent e) { |
| switch (e.type) { |
| case TabFolderEvent.EVENT_MINIMIZE: { |
| getSite().setState(IStackPresentationSite.STATE_MINIMIZED); |
| break; |
| } |
| case TabFolderEvent.EVENT_MAXIMIZE: { |
| getSite().setState(IStackPresentationSite.STATE_MAXIMIZED); |
| break; |
| } |
| case TabFolderEvent.EVENT_RESTORE: { |
| getSite().setState(IStackPresentationSite.STATE_RESTORED); |
| break; |
| } |
| case TabFolderEvent.EVENT_CLOSE: { |
| IPresentablePart part = folder.getPartForTab(e.tab); |
| |
| if (part != null) { |
| getSite().close(new IPresentablePart[] { part }); |
| } |
| break; |
| } |
| case TabFolderEvent.EVENT_SHOW_LIST: { |
| showPartList(); |
| break; |
| } |
| case TabFolderEvent.EVENT_GIVE_FOCUS_TO_PART: { |
| IPresentablePart part = getSite().getSelectedPart(); |
| if (part != null) { |
| part.setFocus(); |
| } |
| break; |
| } |
| case TabFolderEvent.EVENT_PANE_MENU: { |
| IPresentablePart part = getSite().getSelectedPart(); |
| if (part != null) { |
| part.setFocus(); |
| } |
| TabbedStackPresentation.this.showPaneMenu(folder |
| .getPartForTab(e.tab), new Point(e.x, e.y)); |
| break; |
| } |
| case TabFolderEvent.EVENT_DRAG_START: { |
| AbstractTabItem beingDragged = e.tab; |
| Point initialLocation = new Point(e.x, e.y); |
| |
| if (beingDragged == null) { |
| getSite().dragStart(initialLocation, false); |
| } else { |
| IPresentablePart part = folder.getPartForTab(beingDragged); |
| |
| try { |
| dragStart = folder.indexOf(part); |
| getSite().dragStart(part, initialLocation, false); |
| } finally { |
| dragStart = -1; |
| } |
| } |
| break; |
| } |
| case TabFolderEvent.EVENT_TAB_SELECTED: { |
| if (ignoreSelectionChanges > 0) { |
| return; |
| } |
| |
| IPresentablePart part = folder.getPartForTab(e.tab); |
| |
| if (part != null) { |
| getSite().selectPart(part); |
| } |
| break; |
| } |
| case TabFolderEvent.EVENT_SYSTEM_MENU: { |
| IPresentablePart part = folder.getPartForTab(e.tab); |
| |
| if (part == null) { |
| part = getSite().getSelectedPart(); |
| } |
| |
| if (part != null) { |
| showSystemMenu(new Point(e.x, e.y), part); |
| } |
| break; |
| } |
| case TabFolderEvent.EVENT_PREFERRED_SIZE: { |
| IPresentablePart part = folder.getPartForTab(e.tab); |
| if (part == null) { |
| // Standalone views with no title have no tab, so just get the part. |
| IPresentablePart[] parts = getSite().getPartList(); |
| if (parts.length > 0) part = parts[0]; |
| } |
| if (part == getSite().getSelectedPart()) { |
| getSite().flushLayout(); |
| } |
| break; |
| } |
| } |
| } |
| }; |
| |
| private int dragStart = -1; |
| private Map prefs = new HashMap(); |
| |
| public TabbedStackPresentation(IStackPresentationSite site, AbstractTabFolder widget, ISystemMenu systemMenu) { |
| this(site, new PresentablePartFolder(widget), systemMenu); |
| } |
| |
| public TabbedStackPresentation(IStackPresentationSite site, PresentablePartFolder folder, ISystemMenu systemMenu) { |
| this(site, folder, new LeftToRightTabOrder(folder), new ReplaceDragHandler(folder.getTabFolder()), systemMenu); |
| } |
| |
| public TabbedStackPresentation(IStackPresentationSite site, |
| PresentablePartFolder newFolder, TabOrder tabs, TabDragHandler dragBehavior, ISystemMenu systemMenu) { |
| super(site); |
| this.systemMenu = systemMenu; |
| |
| this.folder = newFolder; |
| this.tabs = tabs; |
| this.dragBehavior = dragBehavior; |
| |
| // Add a dispose listener. This will call the presentationDisposed() |
| // method when the widget is destroyed. |
| folder.getTabFolder().getControl().addDisposeListener(new DisposeListener() { |
| public void widgetDisposed(DisposeEvent e) { |
| presentationDisposed(); |
| } |
| }); |
| |
| folder.getTabFolder().addListener(tabFolderListener); |
| |
| this.partList = new DefaultPartList(site, newFolder); |
| } |
| |
| /** |
| * Restores a presentation from a previously stored state |
| * |
| * @param serializer (not null) |
| * @param savedState (not null) |
| */ |
| public void restoreState(IPresentationSerializer serializer, |
| IMemento savedState) { |
| tabs.restoreState(serializer, savedState); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.presentations.StackPresentation#saveState(org.eclipse.ui.presentations.IPresentationSerializer, org.eclipse.ui.IMemento) |
| */ |
| public void saveState(IPresentationSerializer context, IMemento memento) { |
| super.saveState(context, memento); |
| |
| tabs.saveState(context, memento); |
| } |
| |
| /** |
| * Returns true iff the presentation has been disposed |
| * |
| * @return true iff the presentation has been disposed |
| */ |
| private boolean isDisposed() { |
| return folder == null || folder.isDisposed(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.presentations.StackPresentation#setBounds(org.eclipse.swt.graphics.Rectangle) |
| */ |
| public void setBounds(Rectangle bounds) { |
| folder.setBounds(bounds); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.presentations.StackPresentation#computeMinimumSize() |
| */ |
| public Point computeMinimumSize() { |
| return folder.getTabFolder().computeSize(SWT.DEFAULT, SWT.DEFAULT); |
| } |
| |
| /** |
| * Returns the minimum size for this stack, taking into account |
| * the available perpendicular space. |
| * @param width indicates whether a width (=true) or a height (=false) is being computed |
| * @param availablePerpendicular available space perpendicular to the direction being measured |
| * or INFINITE if unbounded (pixels). |
| * @return returns the preferred minimum size (pixels). |
| * This is a width if width == true or a height if width == false. |
| */ |
| private int computePreferredMinimumSize(boolean width, int availablePerpendicular) { |
| int minSize; |
| int hint = availablePerpendicular == INFINITE ? SWT.DEFAULT : availablePerpendicular; |
| if (width) { |
| minSize = folder.getTabFolder().computeSize(SWT.DEFAULT, hint).x; |
| } else { |
| minSize = folder.getTabFolder().computeSize(hint, SWT.DEFAULT).y; |
| } |
| return minSize; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.ISizeProvider#computePreferredSize(boolean, int, int, int) |
| */ |
| public int computePreferredSize(boolean width, int availableParallel, |
| int availablePerpendicular, int preferredResult) { |
| |
| // If there is exactly one part in the stack, this just returns the |
| // preferred size of the part as the preferred size of the stack. |
| IPresentablePart[] parts = getSite().getPartList(); |
| if (parts.length == 1 && parts[0] != null |
| && !(getSite().getState() == IStackPresentationSite.STATE_MINIMIZED)) { |
| int partSize = parts[0].computePreferredSize(width, |
| availableParallel, availablePerpendicular, preferredResult); |
| |
| if (partSize == INFINITE) |
| return partSize; |
| |
| // Adjust preferred size to take into account tab and border trim. |
| int minSize = computePreferredMinimumSize(width, availablePerpendicular); |
| if (width) { |
| // PaneFolder adds some bogus tab spacing, so just find the maximum width. |
| partSize = Math.max(minSize, partSize); |
| } else { |
| // Add them (but only if there's enough room) |
| if (INFINITE-minSize > partSize) |
| partSize += minSize; |
| } |
| |
| return partSize; |
| } |
| |
| if (preferredResult != INFINITE || getSite().getState() == IStackPresentationSite.STATE_MINIMIZED) { |
| int minSize = computePreferredMinimumSize(width, availablePerpendicular); |
| |
| if (getSite().getState() == IStackPresentationSite.STATE_MINIMIZED) { |
| return minSize; |
| } |
| |
| return Math.max(minSize, preferredResult); |
| } |
| |
| return INFINITE; |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.presentations.StackPresentation#getSizeFlags(boolean) |
| */ |
| public int getSizeFlags(boolean width) { |
| int flags = 0; |
| // If there is exactly one part in the stack, |
| // then take into account the size flags of the part. |
| IPresentablePart[] parts = getSite().getPartList(); |
| if (parts.length == 1 && parts[0] != null) { |
| flags |= parts[0].getSizeFlags(width); |
| } |
| |
| return flags | super.getSizeFlags(width); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.presentations.StackPresentation#showPartList() |
| */ |
| public void showPartList() { |
| if (partList != null) { |
| final int numberOfParts = folder.getTabFolder().getItemCount(); |
| if (numberOfParts > 0) { |
| partList.show(getControl(), folder.getTabFolder() |
| .getPartListLocation(), getSite().getSelectedPart()); |
| } |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.presentations.StackPresentation#dispose() |
| */ |
| public void dispose() { |
| // Dispose the tab folder's widgetry |
| folder.getTabFolder().getControl().dispose(); |
| } |
| |
| /** |
| * Called when the tab folder is disposed. |
| */ |
| private void presentationDisposed() { |
| apiPreferences.dispose(); |
| themePreferences.dispose(); |
| |
| Iterator iter = prefs.values().iterator(); |
| while(iter.hasNext()) { |
| PropertyMapAdapter next = (PropertyMapAdapter)iter.next(); |
| next.dispose(); |
| } |
| |
| if (systemMenu != null) { |
| systemMenu.dispose(); |
| } |
| |
| if (partList != null) { |
| partList.dispose(); |
| } |
| |
| systemMenu = null; |
| partList = null; |
| |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.presentations.StackPresentation#setActive(int) |
| */ |
| public void setActive(int newState) { |
| folder.getTabFolder().setActive(newState); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.presentations.StackPresentation#setVisible(boolean) |
| */ |
| public void setVisible(boolean isVisible) { |
| IPresentablePart current = getSite().getSelectedPart(); |
| if (current != null) { |
| current.setVisible(isVisible); |
| } |
| |
| folder.setVisible(isVisible); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.presentations.StackPresentation#setState(int) |
| */ |
| public void setState(int state) { |
| folder.getTabFolder().setState(state); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.presentations.StackPresentation#getControl() |
| */ |
| public Control getControl() { |
| return folder.getTabFolder().getControl(); |
| } |
| |
| /** |
| * @return AbstractTabFolder the presentation's tab folder |
| */ |
| public AbstractTabFolder getTabFolder() { |
| return folder.getTabFolder(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.presentations.StackPresentation#addPart(org.eclipse.ui.presentations.IPresentablePart, java.lang.Object) |
| */ |
| public void addPart(IPresentablePart newPart, Object cookie) { |
| ignoreSelectionChanges++; |
| try { |
| if (initializing) { |
| tabs.addInitial(newPart); |
| } else { |
| if (cookie == null) { |
| tabs.add(newPart); |
| } else { |
| int insertionPoint = dragBehavior |
| .getInsertionPosition(cookie); |
| |
| tabs.insert(newPart, insertionPoint); |
| } |
| } |
| } finally { |
| ignoreSelectionChanges--; |
| } |
| |
| if (tabs.getPartList().length == 1) { |
| if (newPart.getSizeFlags(true) != 0 || newPart.getSizeFlags(false) != 0) { |
| getSite().flushLayout(); |
| } |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.presentations.StackPresentation#movePart(org.eclipse.ui.presentations.IPresentablePart, java.lang.Object) |
| */ |
| public void movePart(IPresentablePart toMove, Object cookie) { |
| ignoreSelectionChanges++; |
| try { |
| int insertionPoint = dragBehavior.getInsertionPosition(cookie); |
| |
| if (insertionPoint == folder.indexOf(toMove)) { |
| return; |
| } |
| |
| tabs.move(toMove, insertionPoint); |
| } finally { |
| ignoreSelectionChanges--; |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.presentations.StackPresentation#removePart(org.eclipse.ui.presentations.IPresentablePart) |
| */ |
| public void removePart(IPresentablePart oldPart) { |
| ignoreSelectionChanges++; |
| try { |
| tabs.remove(oldPart); |
| } finally { |
| ignoreSelectionChanges--; |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.presentations.StackPresentation#selectPart(org.eclipse.ui.presentations.IPresentablePart) |
| */ |
| public void selectPart(IPresentablePart toSelect) { |
| initializing = false; |
| |
| tabs.select(toSelect); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.presentations.StackPresentation#dragOver(org.eclipse.swt.widgets.Control, org.eclipse.swt.graphics.Point) |
| */ |
| public StackDropResult dragOver(Control currentControl, Point location) { |
| return dragBehavior.dragOver(currentControl, location, dragStart); |
| } |
| |
| public void showSystemMenu() { |
| showSystemMenu(folder.getTabFolder().getSystemMenuLocation(), getSite().getSelectedPart()); |
| } |
| |
| public void showSystemMenu(Point displayCoordinates, IPresentablePart context) { |
| if (context != getSite().getSelectedPart()) { |
| getSite().selectPart(context); |
| } |
| systemMenu.show(getControl(), displayCoordinates, context); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.presentations.StackPresentation#showPaneMenu() |
| */ |
| public void showPaneMenu() { |
| IPresentablePart part = getSite().getSelectedPart(); |
| |
| if (part != null) { |
| showPaneMenu(part, folder.getTabFolder().getPaneMenuLocation()); |
| } |
| } |
| |
| public void showPaneMenu(IPresentablePart part, Point location) { |
| Assert.isTrue(!isDisposed()); |
| |
| IPartMenu menu = part.getMenu(); |
| |
| if (menu != null) { |
| menu.showMenu(location); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.presentations.StackPresentation#getTabList(org.eclipse.ui.presentations.IPresentablePart) |
| */ |
| public Control[] getTabList(IPresentablePart part) { |
| ArrayList list = new ArrayList(); |
| if (folder.getTabFolder().getTabPosition() == SWT.BOTTOM) { |
| if (part.getControl() != null) { |
| list.add(part.getControl()); |
| } |
| } |
| |
| list.add(folder.getTabFolder().getControl()); |
| |
| if (part.getToolBar() != null) { |
| list.add(part.getToolBar()); |
| } |
| |
| if (folder.getTabFolder().getTabPosition() == SWT.TOP) { |
| if (part.getControl() != null) { |
| list.add(part.getControl()); |
| } |
| } |
| |
| return (Control[]) list.toArray(new Control[list.size()]); |
| } |
| |
| public void setPartList(ISystemMenu menu) { |
| this.partList = menu; |
| } |
| |
| public IDynamicPropertyMap getTheme() { |
| return themePreferences; |
| } |
| |
| public IDynamicPropertyMap getApiPreferences() { |
| return apiPreferences; |
| } |
| |
| public IDynamicPropertyMap getPluginPreferences(Plugin toQuery) { |
| String id = toQuery.getBundle().getSymbolicName(); |
| IDynamicPropertyMap result = (IDynamicPropertyMap)prefs.get(id); |
| |
| if (result != null) { |
| return result; |
| } |
| |
| result = new PreferencesAdapter(toQuery.getPluginPreferences()); |
| prefs.put(id, result); |
| return result; |
| } |
| |
| /** |
| * Move the tabs around. This is for testing <b>ONLY</b>. |
| * @param part the part to move |
| * @param index the new index |
| * @since 3.2 |
| */ |
| public void moveTab(IPresentablePart part, int index) { |
| tabs.move(part, index); |
| folder.layout(true); |
| } |
| |
| /** |
| * Get the tab list. This is for testing <b>ONLY</b>. |
| * @return the presentable parts in order. |
| * @since 3.2 |
| */ |
| public IPresentablePart[] getPartList() { |
| return tabs.getPartList(); |
| } |
| |
| /** |
| * Cause the folder to hide or show its |
| * Minimize and Maximize affordances. |
| * |
| * @param show |
| * <code>true</code> - the min/max buttons are visible. |
| * @since 3.3 |
| */ |
| public void showMinMax(boolean show) { |
| folder.getTabFolder().showMinMax(show); |
| } |
| } |
