| package org.eclipse.ptp.ui.views; |
| |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.core.runtime.ISafeRunnable; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.jface.action.IMenuListener; |
| import org.eclipse.jface.action.IMenuManager; |
| import org.eclipse.jface.action.MenuManager; |
| import org.eclipse.jface.action.Separator; |
| import org.eclipse.jface.dialogs.ErrorDialog; |
| import org.eclipse.jface.util.SafeRunnable; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.ITreeSelection; |
| import org.eclipse.jface.viewers.TreeViewer; |
| import org.eclipse.ptp.core.IModelManager; |
| import org.eclipse.ptp.core.PTPCorePlugin; |
| import org.eclipse.ptp.core.elementcontrols.IResourceManagerControl; |
| import org.eclipse.ptp.core.elements.IPElement; |
| import org.eclipse.ptp.core.elements.IPMachine; |
| import org.eclipse.ptp.core.elements.IPQueue; |
| import org.eclipse.ptp.core.elements.IResourceManager; |
| import org.eclipse.ptp.core.elements.attributes.ResourceManagerAttributes; |
| import org.eclipse.ptp.core.elements.events.IChangedJobEvent; |
| import org.eclipse.ptp.core.elements.events.IChangedMachineEvent; |
| import org.eclipse.ptp.core.elements.events.IChangedNodeEvent; |
| import org.eclipse.ptp.core.elements.events.IChangedQueueEvent; |
| import org.eclipse.ptp.core.elements.events.IMachineChangeEvent; |
| import org.eclipse.ptp.core.elements.events.INewJobEvent; |
| import org.eclipse.ptp.core.elements.events.INewMachineEvent; |
| import org.eclipse.ptp.core.elements.events.INewNodeEvent; |
| import org.eclipse.ptp.core.elements.events.INewQueueEvent; |
| import org.eclipse.ptp.core.elements.events.IQueueChangeEvent; |
| import org.eclipse.ptp.core.elements.events.IRemoveJobEvent; |
| import org.eclipse.ptp.core.elements.events.IRemoveMachineEvent; |
| import org.eclipse.ptp.core.elements.events.IRemoveNodeEvent; |
| import org.eclipse.ptp.core.elements.events.IRemoveQueueEvent; |
| import org.eclipse.ptp.core.elements.events.IResourceManagerChangeEvent; |
| import org.eclipse.ptp.core.elements.events.IResourceManagerErrorEvent; |
| import org.eclipse.ptp.core.elements.events.IResourceManagerSubmitJobErrorEvent; |
| import org.eclipse.ptp.core.elements.listeners.IMachineChildListener; |
| import org.eclipse.ptp.core.elements.listeners.IMachineListener; |
| import org.eclipse.ptp.core.elements.listeners.IQueueChildListener; |
| import org.eclipse.ptp.core.elements.listeners.IQueueListener; |
| import org.eclipse.ptp.core.elements.listeners.IResourceManagerChildListener; |
| import org.eclipse.ptp.core.elements.listeners.IResourceManagerListener; |
| import org.eclipse.ptp.core.events.IChangedResourceManagerEvent; |
| import org.eclipse.ptp.core.events.INewResourceManagerEvent; |
| import org.eclipse.ptp.core.events.IRemoveResourceManagerEvent; |
| import org.eclipse.ptp.core.listeners.IModelManagerChildListener; |
| import org.eclipse.ptp.rmsystem.IResourceManagerMenuContribution; |
| import org.eclipse.ptp.ui.PTPUIPlugin; |
| import org.eclipse.ptp.ui.UIUtils; |
| import org.eclipse.ptp.ui.actions.AddResourceManagerAction; |
| import org.eclipse.ptp.ui.actions.EditResourceManagerAction; |
| import org.eclipse.ptp.ui.actions.RemoveResourceManagersAction; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.MouseAdapter; |
| import org.eclipse.swt.events.MouseEvent; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Menu; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.swt.widgets.TreeItem; |
| import org.eclipse.ui.IWorkbenchActionConstants; |
| import org.eclipse.ui.model.WorkbenchContentProvider; |
| import org.eclipse.ui.model.WorkbenchLabelProvider; |
| import org.eclipse.ui.part.ViewPart; |
| |
| public class ResourceManagerView extends ViewPart { |
| |
| private final class MachineListener implements IMachineChildListener, IMachineListener { |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.core.elements.listeners.IMachineChildListener#handleEvent(org.eclipse.ptp.core.elements.events.IChangedNodeEvent) |
| */ |
| public void handleEvent(IChangedNodeEvent e) { |
| updateViewer(e.getSource()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.core.elements.listeners.IMachineListener#handleEvent(org.eclipse.ptp.core.elements.events.IMachineChangeEvent) |
| */ |
| public void handleEvent(IMachineChangeEvent e) { |
| updateViewer(e.getSource()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.core.elements.listeners.IMachineChildListener#handleEvent(org.eclipse.ptp.core.elements.events.INewNodeEvent) |
| */ |
| public void handleEvent(INewNodeEvent e) { |
| refreshViewer(e.getSource()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.core.elements.listeners.IMachineChildListener#handleEvent(org.eclipse.ptp.core.elements.events.IRemoveNodeEvent) |
| */ |
| public void handleEvent(IRemoveNodeEvent e) { |
| refreshViewer(e.getSource()); |
| } |
| } |
| |
| private final class MMChildListener implements IModelManagerChildListener { |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.core.events.IModelManagerResourceManagerListener#handleEvent(org.eclipse.ptp.core.events.IChangedResourceManagerEvent) |
| */ |
| public void handleEvent(IChangedResourceManagerEvent e) { |
| // No need to do anything |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.core.events.IModelManagerResourceManagerListener#handleEvent(org.eclipse.ptp.core.events.INewResourceManagerEvent) |
| */ |
| public synchronized void handleEvent(INewResourceManagerEvent e) { |
| final IResourceManager resourceManager = e.getResourceManager(); |
| resourceManagers.add(resourceManager); |
| resourceManager.addElementListener(rmListener); |
| resourceManager.addChildListener(rmChildListener); |
| UIUtils.safeRunAsyncInUIThread(new SafeRunnable(){ |
| public void run() { |
| refreshViewer(PTPCorePlugin.getDefault().getUniverse()); |
| }}); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.core.events.IModelManagerResourceManagerListener#handleEvent(org.eclipse.ptp.core.events.IRemoveResourceManagerEvent) |
| */ |
| public synchronized void handleEvent(IRemoveResourceManagerEvent e) { |
| final IResourceManager resourceManager = e.getResourceManager(); |
| resourceManagers.remove(resourceManager); |
| resourceManager.removeElementListener(rmListener); |
| resourceManager.removeChildListener(rmChildListener); |
| rmChildListener.removeListeners(resourceManager); |
| UIUtils.safeRunAsyncInUIThread(new SafeRunnable(){ |
| public void run() { |
| refreshViewer(PTPCorePlugin.getDefault().getUniverse()); |
| }}); |
| } |
| } |
| |
| private final class QueueListener implements IQueueListener, IQueueChildListener { |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.core.elements.listeners.IQueueChildListener#handleEvent(org.eclipse.ptp.core.elements.events.IChangedJobEvent) |
| */ |
| public void handleEvent(IChangedJobEvent e) { |
| updateViewer(e.getSource()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.core.elements.listeners.IQueueChildListener#handleEvent(org.eclipse.ptp.core.elements.events.INewJobEvent) |
| */ |
| public void handleEvent(INewJobEvent e) { |
| refreshViewer(e.getSource()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.core.elements.listeners.IQueueListener#handleEvent(org.eclipse.ptp.core.elements.events.IQueueChangeEvent) |
| */ |
| public void handleEvent(IQueueChangeEvent e) { |
| updateViewer(e.getSource()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.core.elements.listeners.IQueueChildListener#handleEvent(org.eclipse.ptp.core.elements.events.IRemoveJobEvent) |
| */ |
| public void handleEvent(IRemoveJobEvent e) { |
| refreshViewer(e.getSource()); |
| } |
| |
| } |
| |
| private final class RMChildListener implements |
| IResourceManagerChildListener { |
| private final MachineListener machineListener = new MachineListener(); |
| private QueueListener queueListener = new QueueListener(); |
| private final Set<IPMachine> machines = new HashSet<IPMachine>(); |
| private final Set<IPQueue> queues = new HashSet<IPQueue>(); |
| |
| public synchronized void dispose() { |
| for (IPMachine machine : machines) { |
| removeListeners(machine); |
| } |
| machines.clear(); |
| |
| for (IPQueue queue : queues) { |
| removeListeners(queue); |
| } |
| queues.clear(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.core.elements.listeners.IResourceManagerChildListener#handleEvent(org.eclipse.ptp.core.elements.events.IChangedMachineEvent) |
| */ |
| public void handleEvent(IChangedMachineEvent e) { |
| updateViewer(e.getSource()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.core.elements.listeners.IResourceManagerChildListener#handleEvent(org.eclipse.ptp.core.elements.events.IResourceManagerChangedQueueEvent) |
| */ |
| public void handleEvent(IChangedQueueEvent e) { |
| updateViewer(e.getSource()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.core.elements.listeners.IResourceManagerChildListener#handleEvent(org.eclipse.ptp.core.elements.events.INewMachineEvent) |
| */ |
| public synchronized void handleEvent(INewMachineEvent e) { |
| for (IPMachine machine : e.getMachines()) { |
| machines.add(machine); |
| addListeners(machine); |
| } |
| refreshViewer(e.getSource()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.core.elements.listeners.IResourceManagerChildListener#handleEvent(org.eclipse.ptp.core.elements.events.INewQueueEvent) |
| */ |
| public void handleEvent(INewQueueEvent e) { |
| for (IPQueue queue : e.getQueues()) { |
| queues.add(queue); |
| addListeners(queue); |
| } |
| refreshViewer(e.getSource()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.core.elements.listeners.IResourceManagerChildListener#handleEvent(org.eclipse.ptp.core.elements.events.IRemoveMachineEvent) |
| */ |
| public synchronized void handleEvent(IRemoveMachineEvent e) { |
| for (IPMachine machine : e.getMachines()) { |
| machines.remove(machine); |
| removeListeners(machine); |
| } |
| refreshViewer(e.getSource()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.core.elements.listeners.IResourceManagerChildListener#handleEvent(org.eclipse.ptp.core.elements.events.IResourceManagerRemoveQueueEvent) |
| */ |
| public void handleEvent(IRemoveQueueEvent e) { |
| for (IPQueue queue : e.getQueues()) { |
| queues.remove(queue); |
| removeListeners(queue); |
| } |
| refreshViewer(e.getSource()); |
| } |
| |
| /** |
| * @param resourceManager |
| */ |
| public synchronized void removeListeners(IResourceManager resourceManager) { |
| List<IPMachine> removeMachines = Arrays.asList(resourceManager.getMachines()); |
| removeMachines.retainAll(machines); |
| for (IPMachine machine : removeMachines) { |
| removeListeners(machine); |
| } |
| machines.removeAll(removeMachines); |
| |
| List<IPQueue> removeQueues = Arrays.asList(resourceManager.getQueues()); |
| removeQueues.retainAll(queues); |
| for (IPQueue queue : removeQueues) { |
| removeListeners(queue); |
| } |
| queues.removeAll(removeQueues); |
| } |
| |
| /** |
| * @param machine |
| */ |
| private void addListeners(final IPMachine machine) { |
| machine.addElementListener(machineListener); |
| machine.addChildListener(machineListener); |
| } |
| |
| /** |
| * @param queue |
| */ |
| private void addListeners(final IPQueue queue) { |
| queue.addElementListener(queueListener); |
| queue.addChildListener(queueListener); |
| } |
| |
| /** |
| * @param machine |
| */ |
| private void removeListeners(final IPMachine machine) { |
| machine.removeElementListener(machineListener); |
| machine.removeChildListener(machineListener); |
| } |
| |
| /** |
| * @param queue |
| */ |
| private void removeListeners(IPQueue queue) { |
| queue.removeElementListener(queueListener); |
| queue.removeChildListener(queueListener); |
| } |
| } |
| |
| private final class RMListener implements IResourceManagerListener { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.core.elements.listeners.IResourceManagerListener#handleEvent(org.eclipse.ptp.core.elements.events.IResourceManagerChangedEvent) |
| */ |
| public void handleEvent(IResourceManagerChangeEvent e) { |
| refreshViewer(e.getSource()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.core.elements.listeners.IResourceManagerListener#handleEvent(org.eclipse.ptp.core.elements.events.IResourceManagerErrorEvent) |
| */ |
| public void handleEvent(final IResourceManagerErrorEvent e) { |
| refreshViewer(e.getSource()); |
| UIUtils.safeRunAsyncInUIThread(new SafeRunnable() { |
| public void run() throws Exception { |
| IStatus status = new Status(IStatus.ERROR, PTPUIPlugin.PLUGIN_ID, e.getMessage()); |
| ErrorDialog.openError(PTPUIPlugin.getDisplay().getActiveShell(), "Resource Manager Error", "The \"" + e.getSource().getName() + "\" resource manager reported the following error", status); |
| } |
| }); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.core.elements.listeners.IResourceManagerListener#handleEvent(org.eclipse.ptp.core.elements.events.IResourceManagerSubmitJobErrorEvent) |
| */ |
| public void handleEvent(IResourceManagerSubmitJobErrorEvent e) { |
| // Handled by launch framework |
| } |
| } |
| |
| private final Set<IResourceManager> resourceManagers = new HashSet<IResourceManager>(); |
| |
| private TreeViewer viewer; |
| |
| private RemoveResourceManagersAction removeResourceManagerAction; |
| private AddResourceManagerAction addResourceManagerAction; |
| private EditResourceManagerAction editResourceManagerAction; |
| |
| private final MMChildListener mmChildListener = new MMChildListener(); |
| private final RMListener rmListener = new RMListener(); |
| private final RMChildListener rmChildListener = new RMChildListener(); |
| |
| public ResourceManagerView() { |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.part.WorkbenchPart#createPartControl(org.eclipse.swt.widgets.Composite) |
| */ |
| public void createPartControl(Composite parent) { |
| viewer = new TreeViewer(parent, SWT.MULTI); |
| viewer.setContentProvider(new WorkbenchContentProvider()); |
| viewer.setLabelProvider(new WorkbenchLabelProvider()); |
| |
| viewer.setInput(PTPCorePlugin.getDefault().getUniverse()); |
| |
| // ----------------------------- |
| // Enable right-click popup menu |
| // ----------------------------- |
| createContextMenu(); |
| |
| // ---------------------------------------------------------------------- |
| // Enable property sheet updates when tree items are selected. |
| // Note for this to work each item in the tree must either implement |
| // IPropertySource, or support IPropertySource.class as an adapter type |
| // in its AdapterFactory. |
| // ---------------------------------------------------------------------- |
| getSite().setSelectionProvider(viewer); |
| |
| viewer.getTree().addMouseListener(new MouseAdapter() { |
| /* (non-Javadoc) |
| * @see org.eclipse.swt.events.MouseAdapter#mouseDoubleClick(org.eclipse.swt.events.MouseEvent) |
| */ |
| @Override |
| public void mouseDoubleClick(MouseEvent e) { |
| ITreeSelection selection = (ITreeSelection)viewer.getSelection(); |
| if (!selection.isEmpty()) { |
| IResourceManagerControl rm = (IResourceManagerControl)selection.getFirstElement(); |
| if (rm.getState() == ResourceManagerAttributes.State.STOPPED) { |
| editResourceManagerAction.setResourceManager(rm); |
| editResourceManagerAction.run(); |
| } |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.swt.events.MouseAdapter#mouseDown(org.eclipse.swt.events.MouseEvent) |
| */ |
| public void mouseDown(MouseEvent e) { |
| ISelection selection = viewer.getSelection(); |
| TreeItem item = viewer.getTree().getItem(new Point(e.x, e.y)); |
| if (item == null && !selection.isEmpty()) { |
| viewer.getTree().deselectAll(); |
| } |
| else if (item != null) { |
| } |
| } |
| }); |
| |
| IModelManager mm = PTPCorePlugin.getDefault().getModelManager(); |
| |
| /* |
| * Add us to any existing RM's. I guess it's possible we could |
| * miss a RM if a new event arrives while we're doing this, but is |
| * it a problem? |
| */ |
| for (IResourceManager rm : mm.getUniverse().getResourceManagers()) { |
| rm.addElementListener(rmListener); |
| } |
| mm.addListener(mmChildListener); |
| } |
| |
| public synchronized void dispose() { |
| PTPCorePlugin.getDefault().getModelManager().removeListener(mmChildListener); |
| for (IResourceManager resourceManager : resourceManagers) { |
| resourceManager.removeElementListener(rmListener); |
| resourceManager.removeChildListener(rmChildListener); |
| } |
| resourceManagers.clear(); |
| rmChildListener.dispose(); |
| super.dispose(); |
| } |
| |
| public void setFocus() { |
| viewer.getControl().setFocus(); |
| } |
| |
| private void createContextMenu() { |
| final Shell shell = getSite().getShell(); |
| addResourceManagerAction = new AddResourceManagerAction(shell); |
| removeResourceManagerAction = new RemoveResourceManagersAction(shell); |
| editResourceManagerAction = new EditResourceManagerAction(shell); |
| |
| MenuManager menuManager = new MenuManager("#PopupMenu"); //$NON-NLS-1$ |
| menuManager.setRemoveAllWhenShown(true); |
| menuManager.addMenuListener(new IMenuListener() { |
| public void menuAboutToShow(IMenuManager manager) { |
| fillContextMenu(manager); |
| } |
| }); |
| |
| Menu menu = menuManager.createContextMenu(viewer.getControl()); |
| viewer.getControl().setMenu(menu); |
| getSite().registerContextMenu(menuManager, viewer); |
| } |
| |
| private void fillContextMenu(IMenuManager manager) { |
| final IStructuredSelection selection = (IStructuredSelection) viewer.getSelection(); |
| manager.add(addResourceManagerAction); |
| Object[] selectedObjects = selection.toArray(); |
| boolean inContextForRM = selection.size() > 0; |
| boolean inContextForEditRM = inContextForRM; |
| boolean inContextForRemoveRM = inContextForRM; |
| for (int i = 0; i < selectedObjects.length; ++i) { |
| if (!(selectedObjects[i] instanceof IResourceManagerMenuContribution)) { |
| // Not all of the selected are RMs |
| inContextForRM = false; |
| inContextForEditRM = false; |
| inContextForRemoveRM = false; |
| break; |
| } |
| else { |
| final IResourceManagerMenuContribution menuContrib = (IResourceManagerMenuContribution) selectedObjects[i]; |
| IResourceManagerControl rm = (IResourceManagerControl) menuContrib.getAdapter(IResourceManagerControl.class); |
| if (rm.getState() != ResourceManagerAttributes.State.STOPPED) { |
| inContextForEditRM = false; |
| inContextForRemoveRM = false; |
| } |
| } |
| } |
| manager.add(removeResourceManagerAction); |
| removeResourceManagerAction.setEnabled(inContextForRemoveRM); |
| if (inContextForRemoveRM) { |
| IResourceManagerControl[] rmManagers = new IResourceManagerControl[selection.size()]; |
| for (int i = 0; i < rmManagers.length; ++i) { |
| final IResourceManagerMenuContribution menuContrib = (IResourceManagerMenuContribution) selectedObjects[i]; |
| rmManagers[i] = (IResourceManagerControl) menuContrib.getAdapter(IResourceManagerControl.class); |
| } |
| removeResourceManagerAction.setResourceManager(rmManagers); |
| } |
| manager.add(editResourceManagerAction); |
| editResourceManagerAction.setEnabled(inContextForEditRM); |
| if (inContextForEditRM) { |
| final IResourceManagerMenuContribution menuContrib = (IResourceManagerMenuContribution) selectedObjects[0]; |
| IResourceManagerControl rmManager = (IResourceManagerControl) menuContrib.getAdapter(IResourceManagerControl.class); |
| editResourceManagerAction.setResourceManager(rmManager); |
| } |
| manager.add(new Separator()); |
| manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS)); |
| manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS |
| + "-end")); //$NON-NLS-1$ |
| } |
| |
| private void refreshViewer(final IPElement element) { |
| ISafeRunnable safeRunnable = new SafeRunnable(){ |
| |
| public void run() throws Exception { |
| viewer.refresh(element); |
| } |
| }; |
| UIUtils.safeRunAsyncInUIThread(safeRunnable); |
| } |
| |
| private void updateViewer(final IPElement element) { |
| ISafeRunnable safeRunnable = new SafeRunnable(){ |
| |
| public void run() throws Exception { |
| viewer.update(element, null); |
| } |
| }; |
| UIUtils.safeRunAsyncInUIThread(safeRunnable); |
| } |
| |
| } |