Java tutorial
/******************************************************************************* * Copyright (c) 2012 Tilera 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: * William R. Swanson (Tilera Corporation) *******************************************************************************/ // Package declaration package org.eclipse.cdt.visualizer.ui; // Java classes import java.util.List; // SWT/JFace classes import org.eclipse.jface.action.IMenuListener2; import org.eclipse.jface.action.IMenuManager; import org.eclipse.jface.action.MenuManager; import org.eclipse.jface.viewers.ISelection; import org.eclipse.jface.viewers.ISelectionChangedListener; import org.eclipse.jface.viewers.SelectionChangedEvent; import org.eclipse.swt.graphics.Point; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Menu; import org.eclipse.jface.action.IToolBarManager; // Eclipse/CDT classes import org.eclipse.ui.part.ViewPart; import org.eclipse.ui.IActionBars; // Custom classes import org.eclipse.cdt.visualizer.ui.events.IVisualizerViewerListener; import org.eclipse.cdt.visualizer.ui.events.VisualizerViewerEvent; import org.eclipse.cdt.visualizer.ui.util.SelectionProviderAdapter; import org.eclipse.cdt.visualizer.ui.util.SelectionUtils; import org.eclipse.cdt.visualizer.ui.util.WorkbenchSelectionAdapter; // ---------------------------------------------------------------------------- // VisualizerView // ---------------------------------------------------------------------------- /** * CDT Visualizer View class. * * This is the default implementation of the Visualizer View. * It can also serve as a base class for custom visualizer views. * * The Visualizer View is a simple container with a toolbar, * which presents an instance of an IVisualizerViewer, * and mediates passing of selections to and from the viewer. * * The intent of the VisualizerView class is to encapsulate the * standard Eclipse workbench view support, so the viewer does * not have to worry about such things. */ public class VisualizerView extends ViewPart implements IVisualizerViewerListener, ISelectionChangedListener { // --- members --- /** Whether view has been initialized */ protected boolean m_initialized = false; /** Parent control of view. */ protected Composite m_parentControl = null; /** Contained IVisualizerViewer control. */ protected IVisualizerViewer m_viewer = null; /** Selection change event manager */ protected WorkbenchSelectionAdapter m_workbenchSelectionAdapter = null; /** Context menu manager. */ protected MenuManager m_contextMenuManager = null; /** Last context menu display location. */ protected Point m_contextMenuLocation = null; // --- constructors/destructors --- /** Constructor */ public VisualizerView() { super(); } /** Dispose method */ public void dispose() { super.dispose(); setViewer(null); disposeSelectionHandling(); } // --- accessors --- /** Returns whether view has been initialized. */ public boolean isInitialized() { return m_initialized; } /** Gets contained viewer control. */ public IVisualizerViewer getViewer() { return m_viewer; } /** Sets contained viewer control. */ public void setViewer(IVisualizerViewer viewer) { if (m_viewer != null) { m_viewer.removeSelectionChangedListener(this); m_viewer.removeVisualizerViewerListener(this); } m_viewer = viewer; if (m_viewer != null) { m_viewer.addVisualizerViewerListener(this); m_viewer.addSelectionChangedListener(this); updateUI(); } } // --- ViewPart implementation --- // IMPORTANT: a view may be loaded before the plugins, etc. // that its content depends on, since Eclipse loads saved workbench "memento" state, // including current perspective and view layout, before loading dependent plugins, // and lazily loads plugins based on classes that get touched. // // Hence, a view class should invoke setInitialized(true) at the end // of its createPartControl() method, and any methods that touch/repaint/update // the view's controls, etc. should call isInitialized() to be sure // these controls have been created. /** Invoked when UI controls need to be created */ public void createPartControl(Composite parent) { m_parentControl = parent; // Reminder: Don't muck with the toolbar or toolbar menu here. // (I.e. don't try to clean them out or set initial items.) // VisualizerViewer's selection handling code // allows the selected visualizer to set their content, and // any fiddling you do here will only interfere with that. // set up context menu support initializeContextMenu(); // set up selection handling initializeSelectionHandling(); // initialize viewer control initializeViewer(); m_initialized = true; } /** Invoked when view should take the focus. * Note: this can be invoked before the view is fully initialized * (for example, when loading views from workspace memento information), * in which case it should silently do nothing. */ public void setFocus() { if (m_viewer != null) m_viewer.setFocus(); } // --- initialization support --- /** * Creates and returns VisualizerViewer control. * Intended to be overridden by derived types. */ protected IVisualizerViewer createViewer(Composite parent) { return (m_viewer != null) ? m_viewer : new VisualizerViewer(this, parent); } /** * Invoked by createPartControl() method when view instance is created. * Intended to be overridden by derived classes. */ protected void initializeViewer() { IVisualizerViewer viewer = createViewer(m_parentControl); setViewer(viewer); } // --- tab name management --- /** Sets displayed tab name and description for this view. */ public void setTabName(String displayName) { setPartName(displayName); } /** Sets displayed tab name and description for this view. */ public void setTabDescription(String description) { setTitleToolTip(description); } // --- selection handling --- /** Initializes selection handling for this view. */ protected void initializeSelectionHandling() { // create workbench selection change adapter, // to hook us into the workbench selection event mechanism m_workbenchSelectionAdapter = new WorkbenchSelectionAdapter(this); m_workbenchSelectionAdapter.addSelectionChangedListener(this); } /** Disposes selection handling for this view. */ protected void disposeSelectionHandling() { if (m_workbenchSelectionAdapter != null) { m_workbenchSelectionAdapter.dispose(); m_workbenchSelectionAdapter = null; } } /** Gets current workbench selection. */ public ISelection getWorkbenchSelection() { return m_workbenchSelectionAdapter.getSelection(); } /** Sets current workbench selection, and raises selection changed event. */ public void setWorkbenchSelection(ISelection selection) { m_workbenchSelectionAdapter.setSelection(this, selection); } /** Sets current workbench selection, and raises selection changed event. */ public void setWorkbenchSelection(List<?> selection) { ISelection iselection = SelectionUtils.toSelection(selection); m_workbenchSelectionAdapter.setSelection(this, iselection); } // --- ISelectionChangedListener implementation --- /** Invoked by WorkbenchSelectionAdapter when selection changes, * and by viewer when visualizer selection changes. */ public void selectionChanged(SelectionChangedEvent event) { Object source = event.getSource(); if (source instanceof SelectionProviderAdapter) { source = ((SelectionProviderAdapter) source).getActualSource(); } // if the source is the current VisualizerViewer, // it's a user selection in the viewer, so we want to pass // the selection change on to the workbench if (source == m_viewer) { // tell viewer about workbench selection ISelection selection = event.getSelection(); setWorkbenchSelection(selection); // update toolbar/menu to reflect changed selection updateUI(); } // if the source is this view, it's an echo of a workbench // event we sent out, so ignore it. else if (source == this) { // Do nothing. } // else this is a selection change from some other view // in the workbench, which we should pass down to the viewer else { ISelection selection = event.getSelection(); workbenchSelectionChanged(selection); // update toolbar/menu to reflect changed selection updateUI(); } } /** * Invoked from selectionChanged() when workbench's selection changes, * but only if the selection change did not come from this view. */ public void workbenchSelectionChanged(ISelection selection) { if (m_viewer != null) { m_viewer.workbenchSelectionChanged(selection); } } // --- IVisulizerViewerListener implementation --- /** Invoked when visualizer in view has changed. */ public void visualizerEvent(IVisualizerViewer source, VisualizerViewerEvent event) { switch (event.getType()) { case VisualizerViewerEvent.VISUALIZER_CHANGED: updateUI(); break; case VisualizerViewerEvent.VISUALIZER_CONTEXT_MENU: showContextMenu(event.x, event.y); } } // --- update methods --- /** Updates tab name, toolbar, etc. from viewer. */ public void updateUI() { // Update tab name/tooltip // TODO: internationalize these default strings String name = "Visualizer View"; String description = "Displays visualizations of launches."; if (m_viewer != null) { name = m_viewer.getVisualizerDisplayName(); description = m_viewer.getVisualizerDescription(); } setTabName(name); setTabDescription(description); // Update toolbar & toolbar menu if (m_viewer != null) { IActionBars actionBars = getViewSite().getActionBars(); // Allow presentation to set the displayed toolbar content, if any IToolBarManager toolBarManager = actionBars.getToolBarManager(); toolBarManager.removeAll(); m_viewer.populateToolBar(toolBarManager); toolBarManager.update(true); // Allow presentation to set the toolbar's menu content, if any IMenuManager menuManager = actionBars.getMenuManager(); menuManager.removeAll(); m_viewer.populateMenu(menuManager); menuManager.update(true); // Note: when context menu is invoked, // the poplateContextMenu() method is called by the view, // which in turn delegates to the current visualizer // to populate the context menu. // Propagate the changes actionBars.updateActionBars(); } } // --- context menu support --- /** Sets up context menu support. */ protected void initializeContextMenu() { m_contextMenuManager = new MenuManager(); m_contextMenuManager.addMenuListener(new IMenuListener2() { public void menuAboutToShow(IMenuManager m) { VisualizerView.this.contextMenuShow(m); } public void menuAboutToHide(IMenuManager m) { VisualizerView.this.contextMenuHide(m); } }); // We associate the view's context menu with the parent control. // Viewer has the option of calling showContextMenu() // to display the view's context menu. Menu menu = m_contextMenuManager.createContextMenu(m_parentControl); m_parentControl.setMenu(menu); } /** Invoked when context menu is about to be shown. */ protected void contextMenuShow(IMenuManager m) { m.removeAll(); m_viewer.populateContextMenu(m); m.update(); } /** Invoked when context menu is about to be hidden. */ protected void contextMenuHide(IMenuManager m) { } /** Shows view's context menu at specified position. */ public void showContextMenu(int x, int y) { Menu menu = m_parentControl.getMenu(); if (menu != null) { menu.setLocation(x, y); // capture context menu location in relative coordinates m_contextMenuLocation = m_parentControl.toControl(x, y); // Note: showing menu implicitly invokes populateContextMenu() // to populate context menu items. menu.setVisible(true); // Make sure we have the focus now // so we'll still have it when the menu goes away, // and user doesn't have to click twice. setFocus(); } } /** Gets context menu location. */ public Point getContextMenuLocation() { // Just asking the menu for its own location doesn't work, // so we have to capture it above and return it here. return m_contextMenuLocation; } }