| //------------------------------------------------------------------------------ |
| // Copyright (c) 2005, 2006 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 implementation |
| //------------------------------------------------------------------------------ |
| package org.eclipse.epf.authoring.ui.views; |
| |
| import java.io.File; |
| import java.util.Collection; |
| |
| import org.eclipse.epf.authoring.gef.viewer.ActivityDiagramService; |
| import org.eclipse.epf.authoring.ui.AuthoringUIImages; |
| import org.eclipse.epf.authoring.ui.AuthoringUIPlugin; |
| import org.eclipse.epf.authoring.ui.AuthoringUIResources; |
| import org.eclipse.epf.authoring.ui.BrowsingPerspective; |
| import org.eclipse.epf.authoring.ui.UIActionDispatcher; |
| import org.eclipse.epf.common.ui.util.PerspectiveUtil; |
| import org.eclipse.epf.diagram.ui.service.DiagramImageService; |
| import org.eclipse.epf.library.ILibraryManager; |
| import org.eclipse.epf.library.ILibraryServiceListener; |
| import org.eclipse.epf.library.LibraryService; |
| import org.eclipse.epf.library.events.ILibraryChangeListener; |
| import org.eclipse.epf.library.layout.ElementLayoutManager; |
| import org.eclipse.epf.library.layout.HtmlBuilder; |
| import org.eclipse.epf.library.ui.preferences.LibraryUIPreferences; |
| import org.eclipse.epf.library.util.LibraryUtil; |
| import org.eclipse.epf.uma.MethodConfiguration; |
| import org.eclipse.epf.uma.MethodLibrary; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.action.IToolBarManager; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.SelectionChangedEvent; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.browser.Browser; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.ui.IActionBars; |
| import org.eclipse.ui.IPartListener; |
| import org.eclipse.ui.IPerspectiveDescriptor; |
| import org.eclipse.ui.IPerspectiveListener; |
| import org.eclipse.ui.ISharedImages; |
| import org.eclipse.ui.IViewPart; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchPart; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.part.ViewPart; |
| |
| /** |
| * The Content view. |
| * <p> |
| * Displays the HTML representation of a Method element. |
| * |
| * @author Jinhua Xi |
| * @author Kelvin Low |
| * @since 1.0 |
| */ |
| public class ContentView extends ViewPart { |
| |
| /** |
| * The view ID. |
| */ |
| public static final String VIEW_ID = ContentView.class.getName(); |
| |
| private ElementHTMLViewer contentViewer; |
| |
| private Object displayedElement; |
| |
| private IPartListener partListener = new IPartListener() { |
| public void partActivated(IWorkbenchPart part) { |
| if (part instanceof ContentView && part == ContentView.this) { |
| handleSelection(UIActionDispatcher.getInstance().getSelectionSource(), UIActionDispatcher.getInstance() |
| .getSelection()); |
| } |
| } |
| |
| public void partBroughtToTop(IWorkbenchPart part) { |
| } |
| |
| public void partClosed(IWorkbenchPart part) { |
| } |
| |
| public void partDeactivated(IWorkbenchPart part) { |
| } |
| |
| public void partOpened(IWorkbenchPart part) { |
| } |
| }; |
| |
| private ISelectionChangedListener selectionChangeListener = new ISelectionChangedListener() { |
| public void selectionChanged(SelectionChangedEvent event) { |
| handleSelection(event.getSource(), event.getSelection()); |
| } |
| }; |
| |
| private ILibraryChangeListener libraryChangeListener = new ILibraryChangeListener() { |
| public void libraryChanged(int option, Collection changedItems) { |
| // if (option == ILibraryChangeListener.OPTION_LOADED |
| // || option == ILibraryChangeListener.OPTION_CREATED) { |
| // if (contentViewer != null) { |
| // contentViewer.setHtmlBuilder(new HtmlBuilder()); |
| // contentViewer.getBrowser().redraw(); |
| // } |
| // } |
| |
| if (changedItems != null && displayedElement != null) { |
| if (changedItems.contains(displayedElement)) { |
| displayedElement = null; |
| } |
| } |
| } |
| }; |
| |
| private ILibraryServiceListener libSvcListener = new ILibraryServiceListener() { |
| |
| public void configurationSet(MethodConfiguration config) { |
| contentViewer.getBrowser().setUrl("about:blank"); //$NON-NLS-1$ |
| displayedElement = null; |
| } |
| |
| public void libraryClosed(MethodLibrary library) { |
| } |
| |
| public void libraryCreated(MethodLibrary library) { |
| cleanup(); |
| } |
| |
| public void libraryOpened(MethodLibrary library) { |
| cleanup(); |
| } |
| |
| public void libraryReopened(MethodLibrary library) { |
| cleanup(); |
| } |
| |
| public void librarySet(MethodLibrary library) { |
| } |
| |
| private void cleanup() { |
| if (contentViewer != null) { |
| contentViewer.setHtmlBuilder(new HtmlBuilder()); |
| contentViewer.getBrowser().redraw(); |
| } |
| } |
| }; |
| |
| // Page navigation actions. |
| private Action backAction; |
| |
| private Action forwardAction; |
| |
| private Action stopAction; |
| |
| private Action refreshAction; |
| |
| private Action printAction; |
| |
| // A hidden composite to hold the diagram viewer for diagram image |
| // generation. |
| private Composite diagramViewerHolder; |
| |
| /** |
| * Creates a new instance. |
| */ |
| public ContentView() { |
| } |
| |
| /** |
| * @see org.eclipse.ui.part.WorkbenchPart#createPartControl(Composite) |
| */ |
| public void createPartControl(Composite parent) { |
| try { |
| GridLayout layout = new GridLayout(); |
| layout.marginWidth = 0; |
| layout.marginHeight = 0; |
| layout.horizontalSpacing = 0; |
| layout.verticalSpacing = 0; |
| parent.setLayout(layout); |
| parent.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| |
| contentViewer = new ElementHTMLViewer(parent); |
| diagramViewerHolder = new Composite(parent, SWT.NONE); |
| diagramViewerHolder.setLayoutData(new GridData(1, 1)); // size |
| // can't be |
| // 0,0 |
| // otherwise |
| // the |
| // diagram |
| // will not |
| // be |
| // painted |
| diagramViewerHolder.setLayout(new GridLayout()); |
| diagramViewerHolder.setVisible(false); |
| |
| // Create the page navigation tool buttons. |
| createActions(); |
| |
| // Add a part listener to monitor part activation and update this |
| // view |
| // as and when needed. |
| getSite().getWorkbenchWindow().getPartService().addPartListener( |
| partListener); |
| |
| getSite().getWorkbenchWindow().addPerspectiveListener( |
| new IPerspectiveListener() { |
| public void perspectiveActivated(IWorkbenchPage page, |
| IPerspectiveDescriptor desc) { |
| } |
| |
| public void perspectiveChanged(IWorkbenchPage page, |
| IPerspectiveDescriptor desc, String id) { |
| if (desc.getId().equals( |
| BrowsingPerspective.PERSPECTIVE_ID)) { |
| if (id |
| .equals(IWorkbenchPage.CHANGE_EDITOR_AREA_SHOW)) { |
| page.setEditorAreaVisible(false); |
| AuthoringUIPlugin |
| .getDefault() |
| .getMsgDialog() |
| .displayWarning( |
| AuthoringUIResources.warningDialog_title, |
| AuthoringUIResources.addEditorToPerspectiveWarning_msg); |
| } |
| } |
| } |
| }); |
| |
| // Add selection change listener to update this view as and when |
| // needed. |
| UIActionDispatcher.getInstance().addSelectionChangedListener( |
| selectionChangeListener); |
| |
| LibraryService.getInstance().addListener(libSvcListener); |
| |
| ILibraryManager manager = LibraryService.getInstance().getCurrentLibraryManager(); |
| if (manager != null) { |
| manager.addListener(libraryChangeListener); |
| } |
| } catch (Exception e) { |
| // TODO: Display an error dialog. |
| e.printStackTrace(); |
| } |
| } |
| |
| /** |
| * @see org.eclipse.ui.part.WorkbenchPart#setFocus |
| */ |
| public void setFocus() { |
| contentViewer.setFocus(); |
| } |
| |
| /** |
| * @see org.eclipse.ui.part.WorkbenchPart#dispose |
| */ |
| public void dispose() { |
| LibraryService.getInstance().removeListener(libSvcListener); |
| |
| ILibraryManager manager = LibraryService.getInstance().getCurrentLibraryManager(); |
| if (manager != null) { |
| manager.removeListener(libraryChangeListener); |
| } |
| UIActionDispatcher.getInstance().removeSelectionChangedListener( |
| selectionChangeListener); |
| getSite().getWorkbenchWindow().getPartService().removePartListener( |
| partListener); |
| } |
| |
| /** |
| * Creates the actions for this view. |
| */ |
| protected void createActions() { |
| backAction = new Action() { |
| public void run() { |
| Browser browser = contentViewer.getBrowser(); |
| if (browser != null) { |
| browser.back(); |
| } |
| } |
| }; |
| backAction.setText(AuthoringUIResources.back_text); |
| backAction.setToolTipText(AuthoringUIResources.back_text); |
| backAction.setImageDescriptor(PlatformUI.getWorkbench() |
| .getSharedImages().getImageDescriptor( |
| ISharedImages.IMG_TOOL_BACK)); |
| |
| forwardAction = new Action() { |
| public void run() { |
| Browser browser = contentViewer.getBrowser(); |
| if (browser != null) { |
| browser.forward(); |
| } |
| } |
| }; |
| forwardAction.setText(AuthoringUIResources.forward_text); |
| forwardAction.setToolTipText(AuthoringUIResources.forward_text); |
| forwardAction.setImageDescriptor(PlatformUI.getWorkbench() |
| .getSharedImages().getImageDescriptor( |
| ISharedImages.IMG_TOOL_FORWARD)); |
| |
| stopAction = new Action() { |
| public void run() { |
| Browser browser = contentViewer.getBrowser(); |
| if (browser != null) { |
| browser.stop(); |
| } |
| } |
| }; |
| stopAction.setText(AuthoringUIResources.stop_text); |
| stopAction.setToolTipText(AuthoringUIResources.stop_text); |
| stopAction.setImageDescriptor(AuthoringUIImages.IMG_DESC_STOP); |
| |
| refreshAction = new Action() { |
| public void run() { |
| // Browser browser = contentViewer.getBrowser(); |
| // if (browser != null) { |
| // browser.refresh(); |
| // } |
| |
| // need to regenerate the content |
| contentViewer.refresh(); |
| } |
| }; |
| refreshAction.setText(AuthoringUIResources.refresh_text); |
| refreshAction.setToolTipText(AuthoringUIResources.refresh_text); |
| refreshAction.setImageDescriptor(AuthoringUIImages.IMG_DESC_REFRESH); |
| |
| printAction = new Action() { |
| public void run() { |
| contentViewer.print(); |
| } |
| }; |
| printAction.setText(AuthoringUIResources.print_text); |
| printAction.setToolTipText(AuthoringUIResources.print_text); |
| printAction.setImageDescriptor(AuthoringUIImages.IMG_DESC_PRINT); |
| |
| IActionBars bars = getViewSite().getActionBars(); |
| IToolBarManager manager = bars.getToolBarManager(); |
| manager.add(backAction); |
| manager.add(forwardAction); |
| manager.add(stopAction); |
| manager.add(refreshAction); |
| manager.add(printAction); |
| } |
| |
| protected boolean isViewVisible() { |
| IWorkbenchPage activePage = getSite().getWorkbenchWindow() |
| .getActivePage(); |
| if (activePage == null) { |
| return false; |
| } |
| |
| IViewPart view = activePage.findView(getViewId()); |
| if (view == null) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Handles the given selection. |
| * |
| * @param source |
| * The Library or Configuration view. |
| * @param selection |
| * The selection in the Library or Configuration view. |
| */ |
| protected void handleSelection(Object source, ISelection selection) { |
| if (selection == null || !isViewVisible() ) { |
| return; |
| } |
| |
| if (selection instanceof IStructuredSelection) { |
| IStructuredSelection sel = (IStructuredSelection) selection; |
| Object[] selectedElements = sel.toArray(); |
| if (selectedElements != null && selectedElements.length > 0) { |
| Object element = selectedElements[0]; |
| |
| // don't unwrap the object. |
| // For activity, we need to wrapped item provider to get the suppress status. |
| // Object element = LibraryUtil.unwrap(selectedElement); |
| if (displayedElement != null && displayedElement == element) { |
| displayedElement = null; |
| return; |
| } |
| if (displayContentPage(source, element)) { |
| displayedElement = element; |
| } |
| }else{ |
| contentViewer.getBrowser().setUrl("about:blank"); //$NON-NLS-1$ |
| displayedElement = null; |
| } |
| } |
| } |
| |
| protected boolean isConfigSource(Object source) { |
| return (source != null) && (source instanceof ConfigurationView); |
| } |
| |
| protected ElementLayoutManager getLayoutMgr() { |
| return LibraryService.getInstance() |
| .getCurrentConfigurationManager().getElementLayoutManager(); |
| } |
| |
| protected String getViewId() { |
| return VIEW_ID; |
| } |
| |
| /** |
| * Displays the content page for the given ContentElement. |
| * |
| * @param source |
| * The Library or Configuration view. |
| * @param element |
| * The selected Method element. |
| * @return <code>true</code> if the content page is displayed |
| * successfully. |
| */ |
| protected boolean displayContentPage(Object source, Object raw_element) { |
| Object element = LibraryUtil.unwrap(raw_element); |
| element = ViewHelper.handleDangling(element); |
| if (element == null) { |
| return false; |
| } |
| |
| ElementLayoutManager layoutMgr = null; |
| boolean isBrowsing = PerspectiveUtil |
| .isActivePerspective(BrowsingPerspective.PERSPECTIVE_ID); |
| boolean isConfigSource = isConfigSource(source); |
| |
| // if in browsing but the source is not from configruation view |
| // ignore it |
| if (isBrowsing && !isConfigSource) { |
| return false; |
| } |
| |
| if (isConfigSource) { |
| // Get the Element Layout Manager for the current configuration. |
| layoutMgr = getLayoutMgr(); |
| if ( layoutMgr == null ) { |
| return false; |
| } |
| |
| // Add the activity diagram service to generate diagram images. |
| |
| String newDiagrams = AuthoringUIPlugin.getDefault().getPreferenceStore().getString("PUBLISH_NEW_DIAGRAM"); //$NON-NLS-1$ |
| Boolean newDiagram = new Boolean(true); |
| if(newDiagrams != null && newDiagrams.length() > 0){ |
| newDiagram = new Boolean(newDiagrams); |
| } |
| if(newDiagram.booleanValue()){ |
| DiagramImageService diagramService = (DiagramImageService) layoutMgr |
| .getActivityDiagramService(); |
| if (diagramService == null) { |
| diagramService = new DiagramImageService( |
| diagramViewerHolder, |
| new File(layoutMgr.getPublishDir())); |
| diagramService.setConfig(layoutMgr.getConfiguration()); |
| layoutMgr.setActivityDiagramService(diagramService); |
| } |
| // For Activity Detail Diagram |
| boolean option = LibraryUIPreferences.getPublishUnopenActivitydd(); |
| diagramService.setPublishedUnCreatedADD(option); |
| |
| // For Activity Diagram |
| option = LibraryUIPreferences.getPublishADForActivityExtension(); |
| diagramService.setPublishADForActivityExtension(option); |
| }else{ |
| // Add the activity diagram service to generate diagram images. |
| ActivityDiagramService diagramService = (ActivityDiagramService) layoutMgr |
| .getActivityDiagramService(); |
| if (diagramService == null) { |
| diagramService = new ActivityDiagramService( |
| diagramViewerHolder, |
| new File(layoutMgr.getPublishDir())); |
| layoutMgr.setActivityDiagramService(diagramService); |
| } |
| |
| // For Activity Detail Diagram |
| boolean option = LibraryUIPreferences.getPublishUnopenActivitydd(); |
| diagramService.setPublishedUnCreatedADD(option); |
| |
| // For Activity Diagram |
| option = LibraryUIPreferences.getPublishADForActivityExtension(); |
| diagramService.setPublishADForActivityExtension(option); |
| } |
| |
| |
| |
| } |
| |
| contentViewer.setLayoutManager(layoutMgr); |
| contentViewer.showElementContent(raw_element); |
| |
| return true; |
| } |
| |
| /** |
| * Displays the HTML content page for a Method element. |
| * |
| * @param element |
| * A Method element. |
| * @return <code>true</code> if the HTML content page is displayed |
| * successfully. |
| */ |
| public boolean displayHTMLContentPage(Object element) { |
| element = LibraryUtil.unwrap(element); |
| element = ViewHelper.handleDangling(element); |
| if (element != null) { |
| contentViewer.setLayoutManager(null); |
| contentViewer.showElementContent(element); |
| return true; |
| } |
| return false; |
| } |
| |
| } |
