* Within the workbench there are many views which track the active part. If a
* part is activated these views display some properties for the active part. A
* simple example is the Outline View, which displays the outline
* for the active editor. To avoid loss of context when part activation changes,
* these views may implement a multi-page approach. A separate page is
* maintained within the view for each source view. If a part is activated the
* associated page for the part is brought to top. If a part is closed the
* associated page is disposed. PageBookView is a base
* implementation for multi page views.
*
* PageBookViews provide an IPageSite for each of
* their pages. This site is supplied during the page's initialization. The page
* may supply a selection provider for this site. PageBookViews
* deal with these selection providers in a similar way to a workbench page's
* SelectionService. When a page is made visible, if its site has a
* selection provider, then changes in the selection are listened for and the
* current selection is obtained and fired as a selection change event.
* Selection changes are no longer listened for when a page is made invisible.
*
* This class should be subclassed by clients wishing to define new multi-page * views. *
*
* When a PageBookView is created the following methods are
* invoked. Subclasses must implement these.
*
createDefaultPage - called to create a default page for the
* view. This page is displayed when the active part in the workbench does not
* have a page.getBootstrapPart - called to determine the active part in
* the workbench. A page will be created for this part* When a part is activated the base implementation does not know if a page * should be created for the part. Therefore, it delegates creation to the * subclass. *
isImportant - called when a workbench part is activated.
* Subclasses return whether a page should be created for the new part.doCreatePage - called to create a page for a particular part
* in the workbench. This is only invoked when isImportant returns
* true.* When a part is closed the base implementation will destroy the page * associated with the particular part. The page was created by a subclass, so * the subclass must also destroy it. Subclasses must implement these. *
doDestroyPage - called to destroy a page for a particular
* part in the workbench.null if not initialized.
*/
private PageBook book;
/**
* The page record for the default page.
*/
private PageRec defaultPageRec;
/**
* Map from parts to part records (key type: IWorkbenchPart;
* value type: PartRec).
*/
private final Map mapPartToRec = new HashMap();
/**
* Map from pages to view sites Note that view sites were not added to page
* recs to avoid breaking binary compatibility with previous builds
*/
private final Map mapPageToSite = new HashMap();
/**
* Map from pages to the number of pageRecs actively associated with a page.
*/
private final Map mapPageToNumRecs = new HashMap();
/**
* The page rec which provided the current page or null
*/
private PageRec activeRec;
/**
* If the part is hidden (usually an editor) then store it so we can
* continue to track it when it becomes visible.
*/
private IWorkbenchPart hiddenPart = null;
/**
* The action bar property listener.
*/
private final IPropertyChangeListener actionBarPropListener = new IPropertyChangeListener() {
@Override
public void propertyChange(PropertyChangeEvent event) {
if (event.getProperty().equals(SubActionBars.P_ACTION_HANDLERS)
&& activeRec != null
&& event.getSource() == activeRec.subActionBars) {
refreshGlobalActionHandlers();
}
}
};
/**
* Selection change listener to listen for page selection changes
*/
private final ISelectionChangedListener selectionChangedListener = new ISelectionChangedListener() {
@Override
public void selectionChanged(SelectionChangedEvent event) {
pageSelectionChanged(event);
}
};
/**
* Selection change listener to listen for page selection changes
*/
private final ISelectionChangedListener postSelectionListener = new ISelectionChangedListener() {
@Override
public void selectionChanged(SelectionChangedEvent event) {
postSelectionChanged(event);
}
};
/**
* Selection provider for this view's site
*/
private final SelectionProvider selectionProvider = new SelectionProvider();
/**
* A data structure used to store the information about a single page within
* a pagebook view.
*/
protected static class PageRec {
/**
* The part.
*/
public IWorkbenchPart part;
/**
* The page.
*/
public IPage page;
/**
* The page's action bars
*/
public SubActionBars subActionBars;
/**
* Creates a new page record initialized to the given part and page.
*
* @param part
* @param page
*/
public PageRec(IWorkbenchPart part, IPage page) {
this.part = part;
this.page = page;
}
/**
* Disposes of this page record by nulling its fields.
*/
public void dispose() {
part = null;
page = null;
}
}
private static class SelectionManager extends EventManager {
/**
*
* @param listener
* listen
*/
public void addSelectionChangedListener(
ISelectionChangedListener listener) {
addListenerObject(listener);
}
/**
*
* @param listener
* listen
*/
public void removeSelectionChangedListener(
ISelectionChangedListener listener) {
removeListenerObject(listener);
}
/**
*
* @param event
* the event
*/
public void selectionChanged(final SelectionChangedEvent event) {
// pass on the notification to listeners
Object[] listeners = getListeners();
for (int i = 0; i < listeners.length; ++i) {
final ISelectionChangedListener l = (ISelectionChangedListener) listeners[i];
Platform.run(new SafeRunnable() {
@Override
public void run() {
l.selectionChanged(event);
}
});
}
}
}
/**
* A selection provider/listener for this view. It is a selection provider
* for this view's site.
*/
protected class SelectionProvider implements IPostSelectionProvider {
private final SelectionManager fSelectionListener = new SelectionManager();
private final SelectionManager fPostSelectionListeners = new SelectionManager();
/*
* (non-Javadoc) Method declared on ISelectionProvider.
*/
@Override
public void addSelectionChangedListener(
ISelectionChangedListener listener) {
fSelectionListener.addSelectionChangedListener(listener);
}
/*
* (non-Javadoc) Method declared on ISelectionProvider.
*/
@Override
public ISelection getSelection() {
// get the selection provider from the current page
IPage currentPage = getCurrentPage();
// during workbench startup we may be in a state when
// there is no current page
if (currentPage == null) {
return StructuredSelection.EMPTY;
}
IPageSite site = getPageSite(currentPage);
if (site == null) {
return StructuredSelection.EMPTY;
}
ISelectionProvider selProvider = site.getSelectionProvider();
if (selProvider != null) {
return selProvider.getSelection();
}
return StructuredSelection.EMPTY;
}
/*
* (non-Javadoc) Method declared on ISelectionProvider.
*/
@Override
public void removeSelectionChangedListener(
ISelectionChangedListener listener) {
fSelectionListener.removeSelectionChangedListener(listener);
}
/**
* The selection has changed. Process the event, notifying selection
* listeners and post selection listeners.
*
* @param event
* the change
*/
public void selectionChanged(final SelectionChangedEvent event) {
fSelectionListener.selectionChanged(event);
}
/**
* The selection has changed, so notify any post-selection listeners.
*
* @param event
* the change
*/
public void postSelectionChanged(final SelectionChangedEvent event) {
fPostSelectionListeners.selectionChanged(event);
}
/*
* (non-Javadoc) Method declared on ISelectionProvider.
*/
@Override
public void setSelection(ISelection selection) {
// get the selection provider from the current page
IPage currentPage = getCurrentPage();
// during workbench startup we may be in a state when
// there is no current page
if (currentPage == null) {
return;
}
IPageSite site = getPageSite(currentPage);
if (site == null) {
return;
}
ISelectionProvider selProvider = site.getSelectionProvider();
// and set its selection
if (selProvider != null) {
selProvider.setSelection(selection);
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jface.viewers.IPostSelectionProvider#addPostSelectionChangedListener(org.eclipse.jface.viewers.ISelectionChangedListener)
*/
@Override
public void addPostSelectionChangedListener(
ISelectionChangedListener listener) {
fPostSelectionListeners.addSelectionChangedListener(listener);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jface.viewers.IPostSelectionProvider#removePostSelectionChangedListener(org.eclipse.jface.viewers.ISelectionChangedListener)
*/
@Override
public void removePostSelectionChangedListener(
ISelectionChangedListener listener) {
fPostSelectionListeners.removeSelectionChangedListener(listener);
}
}
/**
* Creates a new pagebook view.
*/
protected PageBookView() {
super();
}
/**
* Creates and returns the default page for this view.
* * Subclasses must implement this method. *
*
* Subclasses must call initPage with the new page (if it is an
* IPageBookViewPage) before calling createControl on the
* page.
*
* Subclasses should call this method after the page is created but before * creating its controls. *
** Subclasses may override *
* * @param page * The page to initialize */ protected void initPage(IPageBookViewPage page) { try { page.init(new PageSite(getViewSite())); } catch (PartInitException e) { WorkbenchPlugin.log(getClass(), "initPage", e); //$NON-NLS-1$ } if(page instanceof IPageBookViewPagePartInit) { ((IPageBookViewPagePartInit)page).initPart(this); } } /** * ThePageBookView implementation of this
* IWorkbenchPart method creates a PageBook
* control with its default page showing. Subclasses may extend.
*/
@Override
public void createPartControl(Composite parent) {
// Create the page book.
book = new PageBook(parent, SWT.NONE);
// Create the default page rec.
IPage defaultPage = createDefaultPage(book);
defaultPageRec = new PageRec(null, defaultPage);
preparePage(defaultPageRec);
// Show the default page
showPageRec(defaultPageRec);
// Listen to part activation events.
getSite().getPage().addPartListener(partListener);
showBootstrapPart();
}
/**
* The PageBookView implementation of this
* IWorkbenchPart method cleans up all the pages. Subclasses
* may extend.
*/
@Override
public void dispose() {
// stop listening to part activation
getSite().getPage().removePartListener(partListener);
// Deref all of the pages.
activeRec = null;
if (defaultPageRec != null) {
// check for null since the default page may not have
// been created (ex. perspective never visible)
defaultPageRec.page.dispose();
defaultPageRec = null;
}
Map clone = (Map) ((HashMap) mapPartToRec).clone();
Iterator itr = clone.values().iterator();
while (itr.hasNext()) {
PageRec rec = (PageRec) itr.next();
removePage(rec);
}
// Run super.
super.dispose();
}
/**
* Creates a new page in the pagebook for a particular part. This page will
* be made visible whenever the part is active, and will be destroyed with a
* call to doDestroyPage.
* * Subclasses must implement this method. *
*
* Subclasses must call initPage with the new page (if it is an
* IPageBookViewPage) before calling createControl on the
* page.
*
doCreatePage.
* * Subclasses must implement this method. *
* * @param part * the input part * @param pageRecord * a page record for the part * @see #doCreatePage */ protected abstract void doDestroyPage(IWorkbenchPart part, PageRec pageRecord); /** * Returns true if the page has already been created. * * @param page * the page to test * @return true if this page has already been created. */ protected boolean doesPageExist(IPage page) { return mapPageToNumRecs.containsKey(page); } /** * ThePageBookView implementation of this
* IAdaptable method delegates to the current page, if it
* implements IAdaptable.
*/
@Override
public Object getAdapter(Class key) {
// delegate to the current page, if supported
IPage page = getCurrentPage();
Object adapter = Adapters.adapt(page, key);
if (adapter != null) {
return adapter;
}
// if the page did not find the adapter, look for one provided by
// this view before delegating to super.
adapter = getViewAdapter(key);
if (adapter != null) {
return adapter;
}
// delegate to super
return super.getAdapter(key);
}
/**
* Returns an adapter of the specified type, as provided by this view (not
* the current page), or null if this view does not provide
* an adapter of the specified adapter.
*
* The default implementation returns null. Subclasses may
* override.
*
null if
* this object does not have an adapter for the given class
* @since 3.2
*/
protected Object getViewAdapter(Class adapter) {
return null;
}
/**
* Returns the active, important workbench part for this view.
*
* When the page book view is created it has no idea which part within the
* workbook should be used to generate the first page. Therefore, it
* delegates the choice to subclasses of PageBookView.
*
* Implementors of this method should return an active, important part in
* the workbench or null if none found.
*
* Subclasses must implement this method. *
* * @return the active important part, ornull if none
*/
protected abstract IWorkbenchPart getBootstrapPart();
/**
* Returns the part which contributed the current page to this view.
*
* @return the part which contributed the current page or null
* if no part contributed the current page
*/
protected IWorkbenchPart getCurrentContributingPart() {
if (activeRec == null) {
return null;
}
return activeRec.part;
}
/**
* Returns the currently visible page for this view or null
* if no page is currently visible.
*
* @return the currently visible page
*/
public IPage getCurrentPage() {
if (activeRec == null) {
return null;
}
return activeRec.page;
}
/**
* Returns the view site for the given page of this view.
*
* @param page
* the page
* @return the corresponding site, or null if not found
*/
protected PageSite getPageSite(IPage page) {
return (PageSite) mapPageToSite.get(page);
}
/**
* Returns the default page for this view.
*
* @return the default page
*/
public IPage getDefaultPage() {
return defaultPageRec.page;
}
/**
* Returns the pagebook control for this view.
*
* @return the pagebook control, or null if not initialized
*/
protected PageBook getPageBook() {
return book;
}
/**
* Returns the page record for the given part.
*
* @param part
* the part
* @return the corresponding page record, or null if not
* found
*/
protected PageRec getPageRec(IWorkbenchPart part) {
return (PageRec) mapPartToRec.get(part);
}
/**
* Returns the page record for the given page of this view.
*
* @param page
* the page
* @return the corresponding page record, or null if not
* found
*/
protected PageRec getPageRec(IPage page) {
Iterator itr = mapPartToRec.values().iterator();
while (itr.hasNext()) {
PageRec rec = (PageRec) itr.next();
if (rec.page == page) {
return rec;
}
}
return null;
}
/**
* Returns whether the given part should be added to this view.
* * Subclasses must implement this method. *
* * @param part * the input part * @returntrue if the part is relevant, and
* false otherwise
*/
protected abstract boolean isImportant(IWorkbenchPart part);
/*
* (non-Javadoc) Method declared on IViewPart.
*/
@Override
public void init(IViewSite site) throws PartInitException {
site.setSelectionProvider(selectionProvider);
super.init(site);
}
/**
* The PageBookView implementation of this
* IPartListener method shows the page when the given part is
* activated. Subclasses may extend.
*/
@Override
public void partActivated(IWorkbenchPart part) {
// Is this an important part? If not just return.
if (!isImportant(part)) {
return;
}
hiddenPart = null;
// Create a page for the part.
PageRec rec = getPageRec(part);
if (rec == null) {
rec = createPage(part);
}
// Show the page.
if (rec != null) {
showPageRec(rec);
} else {
Control[] children = book.getChildren();
//System.out.println("CHILDREN: " + Arrays.toString(children));
if (children.length < 2) {
//System.out.println("showing default page");
showPageRec(defaultPageRec);
}
}
}
/**
* The PageBookView implementation of this
* IPartListener method does nothing. Subclasses may extend.
*/
@Override
public void partBroughtToTop(IWorkbenchPart part) {
// Do nothing by default
}
/**
* The PageBookView implementation of this
* IPartListener method deal with the closing of the active
* part. Subclasses may extend.
*/
@Override
public void partClosed(IWorkbenchPart part) {
// Update the active part.
if (activeRec != null && activeRec.part == part) {
showPageRec(defaultPageRec);
}
// Find and remove the part page.
PageRec rec = getPageRec(part);
if (rec != null) {
removePage(rec);
}
if (part == hiddenPart) {
hiddenPart = null;
}
}
/**
* The PageBookView implementation of this
* IPartListener method does nothing. Subclasses may extend.
*/
@Override
public void partDeactivated(IWorkbenchPart part) {
// Do nothing.
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.IPartListener#partOpened(org.eclipse.ui.IWorkbenchPart)
*/
@Override
public void partOpened(IWorkbenchPart part) {
// Do nothing by default.
}
/**
* Refreshes the global actions for the active page.
*/
private void refreshGlobalActionHandlers() {
// Clear old actions.
IActionBars bars = getViewSite().getActionBars();
bars.clearGlobalActionHandlers();
// Set new actions.
Map newActionHandlers = activeRec.subActionBars
.getGlobalActionHandlers();
if (newActionHandlers != null) {
Set keys = newActionHandlers.entrySet();
Iterator iter = keys.iterator();
while (iter.hasNext()) {
Map.Entry entry = (Map.Entry) iter.next();
bars.setGlobalActionHandler((String) entry.getKey(),
(IAction) entry.getValue());
}
}
}
/**
* Removes a page record. If it is the last reference to the page dispose of
* it - otherwise just decrement the reference count.
*
* @param rec
*/
private void removePage(PageRec rec) {
mapPartToRec.remove(rec.part);
int newCount = ((Integer) mapPageToNumRecs.get(rec.page)).intValue() - 1;
if (newCount == 0) {
Object site = mapPageToSite.remove(rec.page);
mapPageToNumRecs.remove(rec.page);
Control control = rec.page.getControl();
if (control != null && !control.isDisposed()) {
// Dispose the page's control so pages don't have to do this in
// their
// dispose method.
// The page's control is a child of this view's control so if
// this view
// is closed, the page's control will already be disposed.
control.dispose();
}
// free the page
doDestroyPage(rec.part, rec);
if (rec.subActionBars != null) {
rec.subActionBars.dispose();
}
if (site instanceof PageSite) {
((PageSite) site).dispose();
}
} else {
mapPageToNumRecs.put(rec.page, new Integer(newCount));
}
}
/*
* (non-Javadoc) Method declared on IWorkbenchPart.
*/
@Override
public void setFocus() {
// first set focus on the page book, in case the page
// doesn't properly handle setFocus
if (book != null) {
book.setFocus();
}
// then set focus on the page, if any
if (activeRec != null) {
activeRec.page.setFocus();
}
}
/**
* Handle page selection changes.
*
* @param event
*/
private void pageSelectionChanged(SelectionChangedEvent event) {
// forward this change from a page to our site's selection provider
SelectionProvider provider = (SelectionProvider) getSite()
.getSelectionProvider();
if (provider != null) {
provider.selectionChanged(event);
}
}
/**
* Handle page selection changes.
*
* @param event
*/
private void postSelectionChanged(SelectionChangedEvent event) {
// forward this change from a page to our site's selection provider
SelectionProvider provider = (SelectionProvider) getSite()
.getSelectionProvider();
if (provider != null) {
provider.postSelectionChanged(event);
}
}
/**
* Shows a page for the active workbench part.
*/
private void showBootstrapPart() {
IWorkbenchPart part = getBootstrapPart();
if (part != null) {
partActivated(part);
}
}
/**
* Shows page contained in the given page record in this view. The page
* record must be one from this pagebook view.
*
* The PageBookView implementation of this method asks the
* pagebook control to show the given page's control, and records that the
* given page is now current. Subclasses may extend.
*
true if the part is in the viewStack
*/
private boolean containsPart(IViewPart[] viewStack, IWorkbenchPart part) {
if (viewStack == null) {
return false;
}
for (int i = 0; i < viewStack.length; i++) {
if (viewStack[i] == part) {
return true;
}
}
return false;
}
/**
* Make sure that the part is not considered if it is hidden.
*
* @param part
* @since 3.5
*/
protected void partVisible(IWorkbenchPart part) {
if (part == null || part != hiddenPart) {
return;
}
partActivated(part);
}
}