| /******************************************************************************* |
| * Copyright (c) 2004, 2008 Sybase, Inc. and others. |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * Sybase, Inc. - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.jst.jsf.facesconfig.ui.pageflow; |
| |
| import org.eclipse.draw2d.IFigure; |
| import org.eclipse.draw2d.LightweightSystem; |
| import org.eclipse.draw2d.MarginBorder; |
| import org.eclipse.draw2d.Viewport; |
| import org.eclipse.draw2d.parts.ScrollableThumbnail; |
| import org.eclipse.gef.ContextMenuProvider; |
| import org.eclipse.gef.EditDomain; |
| import org.eclipse.gef.EditPart; |
| import org.eclipse.gef.EditPartListener; |
| import org.eclipse.gef.EditPartViewer; |
| import org.eclipse.gef.LayerConstants; |
| import org.eclipse.gef.RootEditPart; |
| import org.eclipse.gef.editparts.ScalableFreeformRootEditPart; |
| import org.eclipse.gef.editparts.ScalableRootEditPart; |
| import org.eclipse.gef.ui.parts.TreeViewer; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.action.IAction; |
| import org.eclipse.jface.action.IToolBarManager; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jst.jsf.facesconfig.ui.EditorPlugin; |
| import org.eclipse.jst.jsf.facesconfig.ui.pageflow.editpart.PageflowTreePartFactory; |
| import org.eclipse.jst.jsf.facesconfig.ui.pageflow.model.PageflowElement; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.widgets.Canvas; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.ui.part.EditorPart; |
| import org.eclipse.ui.part.Page; |
| import org.eclipse.ui.part.PageBook; |
| import org.eclipse.ui.views.contentoutline.IContentOutlinePage; |
| |
| /** |
| * This is an implementation of an outline page showing an overview figure and |
| * an tree outline of the main graphical viewer provided by the current active |
| * page of an multi page editor. |
| * |
| */ |
| public class PageflowEditorOutlinePage extends Page implements |
| IContentOutlinePage { |
| /** the pageflow editor */ |
| private final PageflowEditor editor; |
| |
| /** the outlineContent for the tree viewer */ |
| private PageflowElement outlineContent = null; |
| |
| /** the control of the overview */ |
| private Canvas overview = null; |
| |
| /** the root edit part (outlineContent for the thumbnail) */ |
| private RootEditPart overviewContent = null; |
| |
| /** the thumbnail */ |
| private ScrollableThumbnail thumbnail = null; |
| |
| /** the tree viewer */ |
| private TreeViewer treeViewer = null; |
| |
| /** the control of the tree view */ |
| private Control outline = null; |
| |
| /** the pagebook */ |
| private PageBook pageBook = null; |
| |
| /** action for showing the tree page */ |
| private IAction showOutlineAction = null; |
| |
| /** action for showing the overview page */ |
| private IAction showOverviewAction = null; |
| |
| /** the LightweightSystem */ |
| private LightweightSystem lws = null; |
| |
| /** the edit domain */ |
| private EditDomain editDomain = null; |
| |
| /** |
| * Creates a new PageflowEditorOutlinePage instance. |
| * |
| * @param editor - |
| * Pageflow Editor |
| */ |
| public PageflowEditorOutlinePage(EditorPart editor) { |
| super(); |
| this.editor = (PageflowEditor) editor; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see ISelectionProvider#addSelectionChangedListener(ISelectionChangedListener) |
| */ |
| public void addSelectionChangedListener(ISelectionChangedListener listener) { |
| getTreeViewer().addSelectionChangedListener(listener); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see IPage#createControl(Composite) |
| */ |
| public void createControl(Composite parent) { |
| // pagebook |
| pageBook = new PageBook(parent, SWT.NONE); |
| |
| // tree viewer control |
| outline = getTreeViewer().createControl(pageBook); |
| configureEditPartViewer(getTreeViewer()); |
| |
| // overview canvas |
| overview = new Canvas(pageBook, SWT.NONE); |
| lws = new LightweightSystem(overview); |
| |
| // create actions |
| IToolBarManager tbm = getSite().getActionBars().getToolBarManager(); |
| showOutlineAction = new Action() { |
| public void run() { |
| showPage(outline); |
| } |
| }; |
| showOutlineAction.setImageDescriptor(EditorPlugin.getDefault() |
| .getImageDescriptor("facesconfig/Pageflow_Outline.gif")); //$NON-NLS-1$ |
| tbm.add(showOutlineAction); |
| showOverviewAction = new Action() { |
| public void run() { |
| showPage(overview); |
| } |
| }; |
| showOverviewAction.setImageDescriptor(EditorPlugin.getDefault() |
| .getImageDescriptor("facesconfig/Pageflow_Outline_Overview.gif")); //$NON-NLS-1$ |
| tbm.add(showOverviewAction); |
| |
| // initialize outline page |
| initializeOutlineViewer(); |
| |
| // initialize overview |
| initializeOverview(); |
| |
| // initialize pagebook |
| showPage(outline); |
| } |
| |
| /** |
| * Configures the outline viewer |
| */ |
| private void initializeOutlineViewer() { |
| if (null != getEditDomain()) { |
| getEditDomain().addViewer(getTreeViewer()); |
| } |
| // getTreeViewer().setEditPartFactory(new PageflowTreePartFactory()); |
| |
| // synchronize selections |
| editor.getSelectionSynchronizer().addViewer(getTreeViewer()); |
| |
| // add content |
| getTreeViewer().setContents(getOutlineContent()); |
| } |
| |
| /** |
| * Shows the spcified page. |
| * |
| * @param id - |
| * control id of pagebook in outline page. it is can be _outline |
| * or _overview |
| */ |
| protected void showPage(Control id) { |
| if (id == outline) { |
| showOutlineAction.setChecked(true); |
| showOverviewAction.setChecked(false); |
| pageBook.showPage(outline); |
| if (thumbnail != null) { |
| thumbnail.setVisible(false); |
| } |
| } else if (id == overview) { |
| showOutlineAction.setChecked(false); |
| showOverviewAction.setChecked(true); |
| pageBook.showPage(overview); |
| if (thumbnail != null) { |
| thumbnail.setVisible(true); |
| } |
| } |
| } |
| |
| /** |
| * Returns the current edit domain. |
| * |
| * @return - the edit domain |
| */ |
| public EditDomain getEditDomain() { |
| return editDomain; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see IPage#dispose() |
| */ |
| public void dispose() { |
| editor.getSelectionSynchronizer().removeViewer(getTreeViewer()); |
| |
| if (null != thumbnail) { |
| thumbnail.deactivate(); |
| } |
| |
| super.dispose(); |
| } |
| |
| /** |
| * initialize Overview. |
| * |
| */ |
| private void initializeOverview() { |
| // check if control was created |
| if (null == lws) { |
| return; |
| } |
| |
| // deactivate old thumbnail |
| if (null != thumbnail) { |
| thumbnail.deactivate(); |
| } |
| |
| // create empty thumbnail |
| thumbnail = new ScrollableThumbnail(); |
| thumbnail.setBorder(new MarginBorder(3)); |
| lws.setContents(thumbnail); |
| |
| // initialize thumbnail |
| if (null != getOverviewContent()) { |
| Viewport viewport = null; |
| IFigure source = null; |
| if (getOverviewContent() instanceof ScalableFreeformRootEditPart) { |
| viewport = (Viewport) ((ScalableFreeformRootEditPart) getOverviewContent()) |
| .getFigure(); |
| source = ((ScalableFreeformRootEditPart) getOverviewContent()) |
| .getLayer(LayerConstants.PRINTABLE_LAYERS); |
| } |
| if (getOverviewContent() instanceof ScalableRootEditPart) { |
| viewport = (Viewport) ((ScalableRootEditPart) getOverviewContent()) |
| .getFigure(); |
| source = ((ScalableRootEditPart) getOverviewContent()) |
| .getLayer(LayerConstants.PRINTABLE_LAYERS); |
| } |
| |
| if (null != viewport && null != source) { |
| thumbnail.setViewport(viewport); |
| thumbnail.setSource(source); |
| } |
| } |
| } |
| |
| /** |
| * Returns the outlineContent. |
| * |
| * @return - the outlineContent |
| */ |
| public PageflowElement getOutlineContent() { |
| return outlineContent; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see IPage#getControl() |
| */ |
| public Control getControl() { |
| return pageBook; |
| } |
| |
| /** |
| * Returns the root edit part |
| * |
| * @return - the root edit part |
| */ |
| public RootEditPart getOverviewContent() { |
| return overviewContent; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see ISelectionProvider#getSelection() |
| */ |
| public ISelection getSelection() { |
| return getTreeViewer().getSelection(); |
| } |
| |
| /** |
| * Returns the tree viewer. |
| * |
| * @return - the tree viewer |
| */ |
| public TreeViewer getTreeViewer() { |
| if (null == treeViewer) { |
| treeViewer = new TreeViewer(); |
| treeViewer.setEditPartFactory(new PageflowTreePartFactory()); |
| } |
| |
| return treeViewer; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see ISelectionProvider#removeSelectionChangedListener(ISelectionChangedListener) |
| */ |
| public void removeSelectionChangedListener( |
| ISelectionChangedListener listener) { |
| getTreeViewer().removeSelectionChangedListener(listener); |
| } |
| |
| /** |
| * Sets the outlineContent. |
| * |
| * @param element - |
| * Pageflow Element |
| */ |
| public void setOutlineContent(PageflowElement element) { |
| if (outlineContent != element) { |
| outlineContent = element; |
| |
| // refresh viewer |
| if (null != getTreeViewer().getControl()) { |
| getTreeViewer().setContents(element); |
| |
| // bugfix: something is overwriting visibility |
| if (null != pageBook) { |
| if (showOverviewAction.isChecked()) { |
| showPage(outline); |
| showPage(overview); |
| } else { |
| showPage(outline); |
| } |
| } |
| } |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see IPage#setFocus() |
| */ |
| public void setFocus() { |
| if (getControl() != null) { |
| getControl().setFocus(); |
| } |
| } |
| |
| /** |
| * Sets the root edit part. |
| * |
| * @param part - |
| * root edit part for pageflow model |
| */ |
| public void setOverviewContent(RootEditPart part) { |
| if (overviewContent != part) { |
| overviewContent = part; |
| // reinitialize thumbnail |
| // if (null != thumbnail && thumbnail.isVisible()) |
| initializeOverview(); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see ISelectionProvider#setSelection(ISelection) |
| */ |
| public void setSelection(ISelection selection) { |
| getTreeViewer().setSelection(selection); |
| } |
| |
| /** |
| * Initializes this outline page from a given editor page. |
| * |
| * @param newPage - |
| * Pageflow EditorPage |
| */ |
| public void initialize(PageflowEditor newPage) { |
| if (null != newPage.getGraphicalViewer()) { |
| setOverviewContent(newPage.getGraphicalViewer().getRootEditPart()); |
| EditPart currentContent = newPage.getGraphicalViewer() |
| .getContents(); |
| setOutlineContent(null != currentContent ? (PageflowElement) currentContent |
| .getModel() |
| : null); |
| setEditDomain(newPage.getEditDomain()); |
| getViewerContentListener().setViewer(newPage.getGraphicalViewer()); |
| } else { |
| setOverviewContent(null); |
| setOutlineContent(null); |
| setEditDomain(null); |
| } |
| } |
| |
| /** |
| * Sets the edit domain. |
| * |
| * @param domain - |
| * editor's edit domain |
| */ |
| public void setEditDomain(EditDomain domain) { |
| if (editDomain != domain) { |
| // refresh viewer |
| if (null != getTreeViewer()) { |
| if (null != editDomain) { |
| editDomain.removeViewer(getTreeViewer()); |
| } |
| if (null != domain) { |
| domain.addViewer(getTreeViewer()); |
| } |
| } |
| editDomain = domain; |
| } |
| } |
| |
| /** |
| * the current viewer content listener |
| */ |
| private final ViewerContentListener viewerContentListener = new ViewerContentListener(); |
| |
| /** |
| * This class listens for changes of the content of an EditPartViewer. If |
| * the content changed, it will update the outline viewer. |
| * <p> |
| * Important: this class has to be disposed with |
| * <code>setViewer(null)</code>. |
| * |
| * @author Gunnar Wagenknecht |
| */ |
| private class ViewerContentListener implements EditPartListener { |
| /* the viewer */ |
| private EditPartViewer _viewer; |
| |
| /** |
| * Sets a new viewer. <code>null</code> is allowed to dispose. |
| * |
| * @param viewer |
| */ |
| public void setViewer(EditPartViewer viewer) { |
| if (null != this._viewer) |
| this._viewer.getRootEditPart().removeEditPartListener(this); |
| |
| this._viewer = viewer; |
| |
| if (null != this._viewer) |
| this._viewer.getRootEditPart().addEditPartListener(this); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.gef.EditPartListener#childAdded(org.eclipse.gef.EditPart, |
| * int) |
| */ |
| public void childAdded(EditPart child, int index) { |
| // this is out event, update the viewers |
| if (child.getModel() instanceof PageflowElement) |
| setOutlineContent((PageflowElement) child.getModel()); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.gef.EditPartListener#partActivated(org.eclipse.gef.EditPart) |
| */ |
| public void partActivated(EditPart editpart) { |
| // do nothing |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.gef.EditPartListener#partDeactivated(org.eclipse.gef.EditPart) |
| */ |
| public void partDeactivated(EditPart editpart) { |
| // do nothing |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.gef.EditPartListener#removingChild(org.eclipse.gef.EditPart, |
| * int) |
| */ |
| public void removingChild(EditPart child, int index) { |
| // do nothing |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.gef.EditPartListener#selectedStateChanged(org.eclipse.gef.EditPart) |
| */ |
| public void selectedStateChanged(EditPart editpart) { |
| // do nothing |
| } |
| } |
| |
| /** |
| * Returns the viewer content listener. |
| * |
| * @return the viewer content listener |
| */ |
| private ViewerContentListener getViewerContentListener() { |
| return viewerContentListener; |
| } |
| |
| /** |
| * Configures the specified <code>EditPartViewer</code>. |
| * |
| * @param viewer |
| */ |
| protected void configureEditPartViewer(EditPartViewer viewer) { |
| // configure the shared key handler |
| if (viewer.getKeyHandler() != null) { |
| viewer.getKeyHandler().setParent(editor.getSharedKeyHandler()); |
| } |
| |
| // configure the context menu |
| ContextMenuProvider provider = new PageflowEditorContextMenuProvider( |
| viewer, editor.getActionRegistry()); |
| viewer.setContextMenu(provider); |
| getSite().registerContextMenu( |
| EditorPlugin.getPluginId() |
| + ".pageflow.editor.outlineview.contextmenu", provider, //$NON-NLS-1$ |
| getSite().getSelectionProvider()); |
| } |
| |
| } |