diff options
Diffstat (limited to 'target_explorer/plugins/org.eclipse.tm.te.ui.terminals/src/org/eclipse/tm/te/ui/terminals/tabs/TabFolderManager.java')
| -rw-r--r-- | target_explorer/plugins/org.eclipse.tm.te.ui.terminals/src/org/eclipse/tm/te/ui/terminals/tabs/TabFolderManager.java | 720 |
1 files changed, 720 insertions, 0 deletions
diff --git a/target_explorer/plugins/org.eclipse.tm.te.ui.terminals/src/org/eclipse/tm/te/ui/terminals/tabs/TabFolderManager.java b/target_explorer/plugins/org.eclipse.tm.te.ui.terminals/src/org/eclipse/tm/te/ui/terminals/tabs/TabFolderManager.java new file mode 100644 index 000000000..491548ec4 --- /dev/null +++ b/target_explorer/plugins/org.eclipse.tm.te.ui.terminals/src/org/eclipse/tm/te/ui/terminals/tabs/TabFolderManager.java @@ -0,0 +1,720 @@ +/******************************************************************************* + * Copyright (c) 2011 Wind River Systems, Inc. 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: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.te.ui.terminals.tabs; + +import java.io.UnsupportedEncodingException; +import java.util.ArrayList; +import java.util.EventObject; +import java.util.Iterator; +import java.util.List; + +import org.eclipse.core.runtime.Assert; +import org.eclipse.core.runtime.PlatformObject; +import org.eclipse.jface.resource.JFaceResources; +import org.eclipse.jface.util.IPropertyChangeListener; +import org.eclipse.jface.viewers.ISelection; +import org.eclipse.jface.viewers.ISelectionChangedListener; +import org.eclipse.jface.viewers.ISelectionProvider; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.viewers.SelectionChangedEvent; +import org.eclipse.jface.viewers.StructuredSelection; +import org.eclipse.swt.SWT; +import org.eclipse.swt.custom.CTabFolder; +import org.eclipse.swt.custom.CTabItem; +import org.eclipse.swt.events.DisposeEvent; +import org.eclipse.swt.events.DisposeListener; +import org.eclipse.swt.events.MouseEvent; +import org.eclipse.swt.events.MouseListener; +import org.eclipse.swt.events.SelectionListener; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.layout.FillLayout; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Menu; +import org.eclipse.tm.internal.terminal.control.ITerminalListener; +import org.eclipse.tm.internal.terminal.control.ITerminalViewControl; +import org.eclipse.tm.internal.terminal.control.TerminalViewControlFactory; +import org.eclipse.tm.internal.terminal.provisional.api.ITerminalConnector; +import org.eclipse.tm.internal.terminal.provisional.api.TerminalState; +import org.eclipse.tm.te.runtime.events.EventManager; +import org.eclipse.tm.te.ui.events.AbstractEventListener; +import org.eclipse.tm.te.ui.swt.DisplayUtil; +import org.eclipse.tm.te.ui.terminals.activator.UIPlugin; +import org.eclipse.tm.te.ui.terminals.events.SelectionChangedBroadcastEvent; +import org.eclipse.tm.te.ui.terminals.interfaces.ITerminalsView; +import org.eclipse.tm.te.ui.terminals.interfaces.ImageConsts; +import org.eclipse.ui.PlatformUI; +import org.eclipse.ui.ide.IDEEncoding; + +/** + * Terminals tab folder manager. + */ +@SuppressWarnings("restriction") +public class TabFolderManager extends PlatformObject implements ISelectionProvider { + // Reference to the parent terminal consoles view + private final ITerminalsView parentView; + // Reference to the selection listener instance + private final SelectionListener selectionListener; + // Reference to the broadcasted selection changed event listener instance + private final BroadcastedSelectionChangedEventListener broadcastedSelectionChangedEventListener; + + /** + * List of selection changed listeners. + */ + private final List<ISelectionChangedListener> selectionChangedListeners = new ArrayList<ISelectionChangedListener>(); + + /** + * The terminal control selection listener implementation. + */ + private class TerminalControlSelectionListener implements DisposeListener, MouseListener { + private final ITerminalViewControl terminal; + private boolean selectMode; + + /** + * Constructor. + * + * @param terminal The terminal control. Must be not <code>null</code>. + */ + public TerminalControlSelectionListener(ITerminalViewControl terminal) { + Assert.isNotNull(terminal); + this.terminal = terminal; + + // Register ourself as the required listener + terminal.getControl().addDisposeListener(this); + terminal.getControl().addMouseListener(this); + } + + /** + * Returns the associated terminal view control. + * + * @return The terminal view control. + */ + protected final ITerminalViewControl getTerminal() { + return terminal; + } + + /* (non-Javadoc) + * @see org.eclipse.swt.events.DisposeListener#widgetDisposed(org.eclipse.swt.events.DisposeEvent) + */ + @Override + public void widgetDisposed(DisposeEvent e) { + // Widget got disposed, check if it is ours + // If a tab item gets disposed, we have to dispose the terminal as well + if (e.getSource().equals(terminal.getControl())) { + // Remove as listener + getTerminal().getControl().removeDisposeListener(this); + getTerminal().getControl().removeMouseListener(this); + } + } + + /* (non-Javadoc) + * @see org.eclipse.swt.events.MouseListener#mouseDown(org.eclipse.swt.events.MouseEvent) + */ + @Override + public void mouseDown(MouseEvent e) { + // Left button down -> select mode starts + if (e.button == 1) selectMode = true; + } + + /* (non-Javadoc) + * @see org.eclipse.swt.events.MouseListener#mouseUp(org.eclipse.swt.events.MouseEvent) + */ + @Override + public void mouseUp(MouseEvent e) { + if (e.button == 1 && selectMode) { + selectMode = false; + // Fire a selection changed event with the terminal controls selection + DisplayUtil.safeAsyncExec(new Runnable() { + @Override + public void run() { + fireSelectionChanged(new StructuredSelection(getTerminal().getSelection())); + } + }); + } + } + + /* (non-Javadoc) + * @see org.eclipse.swt.events.MouseListener#mouseDoubleClick(org.eclipse.swt.events.MouseEvent) + */ + @Override + public void mouseDoubleClick(MouseEvent e) { + } + } + + /** + * The event listener to process broadcasted selection changed events + */ + private class BroadcastedSelectionChangedEventListener extends AbstractEventListener { + private final TabFolderManager parent; + + /** + * Constructor. + * + * @param parent The parent tab folder manager. Must not be <code>null</code>. + */ + public BroadcastedSelectionChangedEventListener(TabFolderManager parent) { + super(); + + Assert.isNotNull(parent); + this.parent = parent; + } + + /* (non-Javadoc) + * @see org.eclipse.tm.te.runtime.interfaces.events.IEventListener#eventFired(java.util.EventObject) + */ + @Override + public void eventFired(EventObject event) { + if (event instanceof SelectionChangedBroadcastEvent && !event.getSource().equals(parent)) { + // Don't need to do anything if the parent tab folder is disposed or does not have a open tab + CTabFolder tabFolder = parent.getTabFolder(); + if (tabFolder == null || tabFolder.isDisposed() || tabFolder.getItemCount() == 0) return; + + // Received a broadcasted selection changed event from another tab folder manager. + SelectionChangedEvent selectionChangedEvent = ((SelectionChangedBroadcastEvent)event).getSelectionChangedEvent(); + if (selectionChangedEvent != null && selectionChangedEvent.getSelection() instanceof IStructuredSelection && !selectionChangedEvent.getSelection().isEmpty()) { + // Extract the selection from the selection changed event + IStructuredSelection selection = (IStructuredSelection)selectionChangedEvent.getSelection(); + // Determine the first element in the selection being a CTabItem + CTabItem item = null; + Iterator<?> iterator = selection.iterator(); + while (iterator.hasNext()) { + Object candidate = iterator.next(); + if (candidate instanceof CTabItem) { item = (CTabItem)candidate; break; } + } + // If we got an CTabItem from the selection, try to find a CTabItem in our own tab folder manager + // which is associated with the exact same data object. + if (item != null && item.getData("customData") != null) { //$NON-NLS-1$ + Object data = item.getData("customData"); //$NON-NLS-1$ + + CTabItem[] ourItems = tabFolder.getItems(); + for (CTabItem ourItem : ourItems) { + Object ourData = ourItem.getData("customData"); //$NON-NLS-1$ + if (data.equals(ourData) && !ourItem.equals(parent.getActiveTabItem())) { + // Select this item and we are done + parent.setSelection(new StructuredSelection(ourItem)); + break; + } + } + } + } + } + } + + } + + /** + * Constructor. + * + * @param parentView The parent terminal console view. Must be not <code>null</code>. + */ + public TabFolderManager(ITerminalsView parentView) { + super(); + Assert.isNotNull(parentView); + this.parentView = parentView; + + // Attach a selection listener to the tab folder + selectionListener = doCreateTabFolderSelectionListener(this); + if (getTabFolder() != null) getTabFolder().addSelectionListener(selectionListener); + + + // Create and register the broadcasted selection changed event listener + broadcastedSelectionChangedEventListener = doCreateBroadcastedSelectionChangedEventListener(this); + if (isListeningToBroadcastedSelectionChangedEvent() && broadcastedSelectionChangedEventListener != null) { + EventManager.getInstance().addEventListener(broadcastedSelectionChangedEventListener, SelectionChangedBroadcastEvent.class); + } + } + + /** + * Creates the terminal console tab folder selection listener instance. + * + * @param parent The parent terminal console tab folder manager. Must be not <code>null</code>. + * @return The selection listener instance. + */ + protected TabFolderSelectionListener doCreateTabFolderSelectionListener(TabFolderManager parent) { + Assert.isNotNull(parent); + return new TabFolderSelectionListener(parent); + } + + /** + * Returns the parent terminal consoles view. + * + * @return The terminal consoles view instance. + */ + protected final ITerminalsView getParentView() { + return parentView; + } + + /** + * Returns the tab folder associated with the parent view. + * + * @return The tab folder or <code>null</code>. + */ + protected final CTabFolder getTabFolder() { + return (CTabFolder)getParentView().getAdapter(CTabFolder.class); + } + + /** + * Returns the selection changed listeners currently registered. + * + * @return The registered selection changed listeners or an empty array. + */ + protected final ISelectionChangedListener[] getSelectionChangedListeners() { + return selectionChangedListeners.toArray(new ISelectionChangedListener[selectionChangedListeners.size()]); + } + + /** + * Dispose the tab folder manager instance. + */ + public void dispose() { + // Dispose the selection listener + if (getTabFolder() != null && !getTabFolder().isDisposed()) getTabFolder().removeSelectionListener(selectionListener); + // Remove the broadcasted selection changed event listener from the notification manager + if (broadcastedSelectionChangedEventListener != null) { + EventManager.getInstance().removeEventListener(broadcastedSelectionChangedEventListener); + } + } + + /** + * Creates a new tab item with the given title and connector. + * + * @param title The tab title. Must be not <code>null</code>. + * @param connector The terminal connector. Must be not <code>null</code>. + * @param data The custom terminal data node or <code>null</code>. + * + * @return The created tab item or <code>null</code> if failed. + */ + @SuppressWarnings("unused") + public CTabItem createTabItem(String title, ITerminalConnector connector, Object data) { + Assert.isNotNull(title); + Assert.isNotNull(connector); + + // The result tab item + CTabItem item = null; + + // Get the tab folder from the parent viewer + CTabFolder tabFolder = getTabFolder(); + if (tabFolder != null) { + // Generate a unique title string for the new tab item (must be called before creating the item itself) + title = makeUniqueTitle(title, tabFolder); + // Create the tab item + item = new CTabItem(tabFolder, SWT.CLOSE); + // Set the tab item title + item.setText(title); + // Set the tab icon + Image image = getTabItemImage(connector, data); + if (image != null) item.setImage(image); + + // Setup the tab item listeners + setupTerminalTabListeners(item); + + // Create the composite to create the terminal control within + Composite composite = new Composite(tabFolder, SWT.NONE); + composite.setLayout(new FillLayout()); + // Associate the composite with the tab item + item.setControl(composite); + + // Refresh the layout + tabFolder.getParent().layout(true); + + // Create the terminal control + ITerminalViewControl terminal = TerminalViewControlFactory.makeControl(doCreateTerminalTabTerminalListener(item), composite, new ITerminalConnector[] { connector }); + // Add the "selection" listener to the terminal control + new TerminalControlSelectionListener(terminal); + // Use the default Eclipse IDE encoding setting to configure the terminals encoding + try { terminal.setEncoding(IDEEncoding.getResourceEncoding()); } catch (UnsupportedEncodingException e) { /* ignored on purpose */ } + // Associated the terminal with the tab item + item.setData(terminal); + // Associated the custom data node with the tab item (if any) + if (data != null) item.setData("customData", data); //$NON-NLS-1$ + + // Overwrite the text canvas help id + String contextHelpId = getParentView().getContextHelpId(); + if (contextHelpId != null) { + PlatformUI.getWorkbench().getHelpSystem().setHelp(terminal.getControl(), contextHelpId); + } + + // Set the context menu + TabFolderMenuHandler menuHandler = (TabFolderMenuHandler)getParentView().getAdapter(TabFolderMenuHandler.class); + if (menuHandler != null) { + Menu menu = (Menu)menuHandler.getAdapter(Menu.class); + if (menu != null) { + // One weird occurrence of IllegalArgumentException: Widget has wrong parent. + // Inspecting the code, this seem extremely unlikely. The terminal is created + // from a composite parent, the composite parent from the tab folder and the menu + // from the tab folder. Means, at the end all should have the same menu shell, shouldn't they? + try { + terminal.getControl().setMenu(menu); + } catch (IllegalArgumentException e) { + // Log exception only if debug mode is set to 1. + if (UIPlugin.getTraceHandler().isSlotEnabled(1, null)) { + e.printStackTrace(); + } + } + } + } + + // Select the created item within the tab folder + tabFolder.setSelection(item); + + // Set the connector + terminal.setConnector(connector); + + // And connect the terminal + terminal.connectTerminal(); + + // Fire selection changed event + fireSelectionChanged(); + } + + // Return the create tab item finally. + return item; + } + + /** + * Generate a unique title string based on the given proposal. + * + * @param proposal The proposal. Must be not <code>null</code>. + * @return The unique title string. + */ + protected String makeUniqueTitle(String proposal, CTabFolder tabFolder) { + Assert.isNotNull(proposal); + Assert.isNotNull(tabFolder); + + String title = proposal; + int index = 0; + + // Loop all existing tab items and check the titles. We have to remember + // all found titles as modifying the proposal might in turn conflict again + // with the title of a tab already checked. + List<String> titles = new ArrayList<String>(); + for (CTabItem item : tabFolder.getItems()) { + // Get the tab item title + titles.add(item.getText()); + // Make the proposal unique be appending (<n>) against all known titles. + while (titles.contains(title)) title = proposal + " (" + index++ + ")"; //$NON-NLS-1$ //$NON-NLS-2$ + } + + return title; + } + + /** + * Setup the terminal console tab item listeners. + * + * @param item The tab item. Must be not <code>null</code>. + */ + protected void setupTerminalTabListeners(CTabItem item) { + Assert.isNotNull(item); + + // Create and associate the disposal listener + item.addDisposeListener(doCreateTerminalTabDisposeListener(this)); + + // Create and register the property change listener + final IPropertyChangeListener propertyChangeListener = doCreateTerminalTabPropertyChangeListener(item); + // Register to the JFace font registry + JFaceResources.getFontRegistry().addListener(propertyChangeListener); + // Remove the listener from the JFace font registry if the tab gets disposed + item.addDisposeListener(new DisposeListener() { + @Override + public void widgetDisposed(DisposeEvent e) { + JFaceResources.getFontRegistry().removeListener(propertyChangeListener); + } + }); + } + + /** + * Creates a new terminal console tab terminal listener instance. + * + * @param item The tab item. Must be not <code>null</code>. + * @return The terminal listener instance. + */ + protected ITerminalListener doCreateTerminalTabTerminalListener(CTabItem item) { + Assert.isNotNull(item); + return new TabTerminalListener(item); + } + + /** + * Creates a new terminal console tab dispose listener instance. + * + * @param parent The parent terminal console tab folder manager. Must be not <code>null</code>. + * @return The dispose listener instance. + */ + protected DisposeListener doCreateTerminalTabDisposeListener(TabFolderManager parent) { + Assert.isNotNull(parent); + return new TabDisposeListener(parent); + } + + /** + * Creates a new terminal console tab property change listener instance. + * + * @param item The tab item. Must be not <code>null</code>. + * @return The property change listener instance. + */ + protected IPropertyChangeListener doCreateTerminalTabPropertyChangeListener(CTabItem item) { + Assert.isNotNull(item); + return new TabPropertyChangeListener(item); + } + + /** + * Returns the tab item image. + * + * @param connector The terminal connector. Must be not <code>null</code>. + * @param data The custom terminal data node or <code>null</code>. + * + * @return The tab item image or <code>null</code>. + */ + protected Image getTabItemImage(ITerminalConnector connector, Object data) { + Assert.isNotNull(connector); + return UIPlugin.getImage(ImageConsts.VIEW_Terminals); + } + + /** + * Lookup a tab item with the given title and the given terminal connector. + * <p> + * <b>Note:</b> The method will handle unified tab item titles itself. + * + * @param title The tab item title. Must be not <code>null</code>. + * @param connector The terminal connector. Must be not <code>null</code>. + * @param data The custom terminal data node or <code>null</code>. + * + * @return The corresponding tab item or <code>null</code>. + */ + public CTabItem findTabItem(String title, ITerminalConnector connector, Object data) { + Assert.isNotNull(title); + Assert.isNotNull(connector); + + // Get the tab folder + CTabFolder tabFolder = getTabFolder(); + if (tabFolder == null) return null; + + // Loop all existing tab items and try to find a matching title + for (CTabItem item : tabFolder.getItems()) { + // Disposed items cannot be matched + if (item.isDisposed()) continue; + // Get the title from the current tab item + String itemTitle = item.getText(); + // The terminal console state might be signaled to the user via the + // terminal console tab title. Filter out any prefix "<.*>\s*". + itemTitle = itemTitle.replaceFirst("^<.*>\\s*", ""); //$NON-NLS-1$ //$NON-NLS-2$ + if (itemTitle.startsWith(title)) { + // The title string matches -> double check with the terminal connector + ITerminalViewControl terminal = (ITerminalViewControl)item.getData(); + ITerminalConnector connector2 = terminal.getTerminalConnector(); + // If the connector id and name matches -> check on the settings + if (connector.getId().equals(connector2.getId()) && connector.getName().equals(connector2.getName())) { + if (!connector.isInitialized()) { + // an uninitialized connector does not yield a sensible summary + return item; + } + String summary = connector.getSettingsSummary(); + String summary2 = connector2.getSettingsSummary(); + // If we have matching settings -> we've found the matching item + if (summary.equals(summary2)) return item; + } + } + } + + return null; + } + + /** + * Make the given tab item the active tab and bring the tab to the top. + * + * @param item The tab item. Must be not <code>null</code>. + */ + public void bringToTop(CTabItem item) { + Assert.isNotNull(item); + + // Get the tab folder + CTabFolder tabFolder = getTabFolder(); + if (tabFolder == null) return; + + // Set the given tab item as selection to the tab folder + tabFolder.setSelection(item); + // Fire selection changed event + fireSelectionChanged(); + } + + /** + * Returns the currently active tab. + * + * @return The active tab item or <code>null</code> if none. + */ + public CTabItem getActiveTabItem() { + // Get the tab folder + CTabFolder tabFolder = getTabFolder(); + if (tabFolder == null) return null; + + return tabFolder.getSelection(); + } + + /** + * Remove all terminated tab items. + */ + public void removeTerminatedItems() { + // Get the tab folder + CTabFolder tabFolder = getTabFolder(); + if (tabFolder == null) return; + + // Loop the items and check for terminated status + for (CTabItem item: tabFolder.getItems()) { + // Disposed items cannot be matched + if (item.isDisposed()) continue; + // Check if the item is terminated + if (isTerminatedTabItem(item)) { + // item is terminated -> dispose + item.dispose(); + } + } + } + + /** + * Checks if the given tab item represents a terminated console. Subclasses may + * overwrite this method to extend the definition of terminated. + * + * @param item The tab item or <code>null</code>. + * @return <code>True</code> if the tab item represents a terminated console, <code>false</code> otherwise. + */ + protected boolean isTerminatedTabItem(CTabItem item) { + // Null items or disposed items cannot be matched + if (item == null || item.isDisposed()) return false; + + // First, match the item title. If it contains "<terminated>", the item can be removed + String itemTitle = item.getText(); + if (itemTitle != null && itemTitle.contains("<terminated>")) { //$NON-NLS-1$ + return true; + } + // Second, check if the associated terminal control is closed + // The title string matches -> double check with the terminal connector + ITerminalViewControl terminal = (ITerminalViewControl)item.getData(); + if (terminal != null && terminal.getState() == TerminalState.CLOSED) { + return true; + } + + return false; + } + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.ISelectionProvider#addSelectionChangedListener(org.eclipse.jface.viewers.ISelectionChangedListener) + */ + @Override + public void addSelectionChangedListener(ISelectionChangedListener listener) { + if (listener != null && !selectionChangedListeners.contains(listener)) selectionChangedListeners.add(listener); + } + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.ISelectionProvider#removeSelectionChangedListener(org.eclipse.jface.viewers.ISelectionChangedListener) + */ + @Override + public void removeSelectionChangedListener(ISelectionChangedListener listener) { + if (listener != null) selectionChangedListeners.remove(listener); + } + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.ISelectionProvider#getSelection() + */ + @Override + public ISelection getSelection() { + CTabItem activeTabItem = getActiveTabItem(); + return activeTabItem != null ? new StructuredSelection(activeTabItem) : new StructuredSelection(); + } + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.ISelectionProvider#setSelection(org.eclipse.jface.viewers.ISelection) + */ + @Override + public void setSelection(ISelection selection) { + if (selection instanceof IStructuredSelection && !selection.isEmpty()) { + // The first selection element which is a CTabItem will become the active item + Iterator<?> iterator = ((IStructuredSelection)selection).iterator(); + while (iterator.hasNext()) { + Object candidate = iterator.next(); + if (candidate instanceof CTabItem) { bringToTop((CTabItem)candidate); return; } + } + } + // fire a changed event in any case + fireSelectionChanged(selection); + } + + /** + * Fire the selection changed event to the registered listeners. + */ + protected void fireSelectionChanged() { + fireSelectionChanged(getSelection()); + } + + /** + * Fire the selection changed event to the registered listeners. + */ + protected final void fireSelectionChanged(ISelection selection) { + // Create the selection changed event + SelectionChangedEvent event = new SelectionChangedEvent(TabFolderManager.this, selection); + + // First, invoke the registered listeners and let them do their job + for (ISelectionChangedListener listener : selectionChangedListeners) { + listener.selectionChanged(event); + } + + // Second, broadcast the event if desired + if (isBroadcastSelectionChangedEvent()) onBroadcastSelectionChangedEvent(event); + } + + /** + * Controls if or if not a selection changed event, processed by this tab + * folder manager shall be broadcasted to via the global Workbench notification + * mechanism. + * + * @return <code>True</code> to broadcast the selection changed event, <code>false</code> otherwise. + */ + protected boolean isBroadcastSelectionChangedEvent() { + return false; + } + + /** + * Broadcasts the given selection changed event via the global Workbench notification mechanism. + * + * @param selectionChangedEvent The selection changed event or <code>null</code>. + */ + protected void onBroadcastSelectionChangedEvent(SelectionChangedEvent selectionChangedEvent) { + SelectionChangedBroadcastEvent event = doCreateSelectionChangedBroadcastEvent(this, selectionChangedEvent); + if (event != null) EventManager.getInstance().fireEvent(event); + } + + /** + * Creates the selection changed broadcast event. + * + * @param source The event source. Must not be <code>null</code>. + * @param selectionChangedEvent The selection changed event or <code>null</code>. + * + * @return The selection changed broadcast event or <code>null</code>. + */ + protected SelectionChangedBroadcastEvent doCreateSelectionChangedBroadcastEvent(TabFolderManager source, SelectionChangedEvent selectionChangedEvent) { + return new SelectionChangedBroadcastEvent(source, selectionChangedEvent); + } + + /** + * Returns if or if not this tab folder manager is listening to broadcasted selection + * changed events. Broadcasted events by the same tab folder manager are ignored independent + * of the methods return value. + * + * @return <code>True</code> to listen to broadcasted selection changed events, <code>false</code> to not listen. + */ + protected boolean isListeningToBroadcastedSelectionChangedEvent() { + return false; + } + + /** + * Creates a new broadcasted selection changed event listener instance. + * + * @param parent The parent tab folder manager. Must not be <code>null</code>. + * @return The event listener instance or <code>null</code>. + */ + protected BroadcastedSelectionChangedEventListener doCreateBroadcastedSelectionChangedEventListener(TabFolderManager parent) { + return new BroadcastedSelectionChangedEventListener(parent); + } +} |