/****************************************************************************
* Copyright (c) 2007 Composent, 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:
* Composent, Inc. - initial API and implementation
*****************************************************************************/
package org.eclipse.ecf.presence.ui.menu;
import java.util.*;
import org.eclipse.core.commands.Command;
import org.eclipse.core.commands.IHandler;
import org.eclipse.core.runtime.Assert;
import org.eclipse.ecf.core.IContainer;
import org.eclipse.ecf.core.IContainerManager;
import org.eclipse.ecf.internal.presence.ui.Activator;
import org.eclipse.ecf.presence.IPresence;
import org.eclipse.ecf.presence.IPresenceContainerAdapter;
import org.eclipse.ecf.presence.roster.*;
import org.eclipse.ecf.ui.SharedImages;
import org.eclipse.jface.action.*;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.CompoundContributionItem;
import org.eclipse.ui.commands.ICommandService;
import org.eclipse.ui.handlers.IHandlerService;
import org.eclipse.ui.menus.CommandContributionItem;
import org.eclipse.ui.menus.CommandContributionItemParameter;
import org.eclipse.ui.services.IServiceLocator;
/**
* A contribution that dynamically constructs a menu for the currently connected rosters.
* This class may be subclassed in order to create a {@link AbstractRosterMenuHandler} for
* handling selection of a given {@link IRosterEntry} from the menu.
*/
public abstract class AbstractRosterMenuContributionItem extends CompoundContributionItem {
private static final String DEFAULT_TOP_MENU_NAME = "Share"; //$NON-NLS-1$
protected static final IContributionItem[] NO_CONTRIBUTIONS = new IContributionItem[] {};
private static final String ROSTERCOMMAND_PREFIX = "org.eclipse.ecf.presence.ui.rosterCommand."; //$NON-NLS-1$
private static final List handlerActivations = new ArrayList();
private static int commandIdIndex = 0;
private IServiceLocator serviceLocator;
private IHandlerService handlerService;
private ICommandService commandService;
private String topMenuName = DEFAULT_TOP_MENU_NAME;
private ImageDescriptor topMenuImageDescriptor = Activator.getDefault().getImageRegistry().getDescriptor(Activator.COLLABORATION_IMAGE);
protected void setTopMenuName(String name) {
this.topMenuName = name;
}
public void setTopMenuImageDescriptor(ImageDescriptor image) {
this.topMenuImageDescriptor = image;
}
protected ImageDescriptor getTopMenuImageDescriptor() {
return this.topMenuImageDescriptor;
}
private void initialize() {
serviceLocator = PlatformUI.getWorkbench();
Assert.isNotNull(serviceLocator);
handlerService = (IHandlerService) serviceLocator.getService(IHandlerService.class);
Assert.isNotNull(handlerService);
commandService = (ICommandService) serviceLocator.getService(ICommandService.class);
Assert.isNotNull(commandService);
}
public AbstractRosterMenuContributionItem() {
initialize();
}
public AbstractRosterMenuContributionItem(String id) {
super(id);
initialize();
}
/**
* Create contribution items for a given roster. Subclasses may override as appropriate
* to customize the creation of contributions with an alternative strategy.
* @param roster the roster to create contribution items for. Must not be <code>null</code>.
* @return IContributionItem[] for given IRoster. Will not return <code>null</code>.
*
*/
protected IContributionItem[] createContributionItemsForRoster(IRoster roster) {
Collection rosterItems = roster.getItems();
List contributions = new ArrayList();
for (Iterator i = rosterItems.iterator(); i.hasNext();) {
IRosterItem item = (IRosterItem) i.next();
IContributionItem[] adds = null;
if (item instanceof IRosterEntry) {
adds = createContributionItemsForEntry((IRosterEntry) item);
} else if (item instanceof IRosterGroup) {
adds = createContributionItemsForGroup((IRosterGroup) item);
}
if (adds != null) {
for (int j = 0; j < adds.length; j++) {
contributions.add(adds[j]);
}
}
}
return (IContributionItem[]) contributions.toArray(new IContributionItem[] {});
}
/**
* Create contribution items for a given roster. Subclasses may override as appropriate
* to customize the creation of contributions with an alternative strategy.
* @param group the IRosterGroup to create contribution items for. Must not be <code>null</code>.
* @return IContributionItem[] for given IRosterGroup. Will not return <code>null</code>.
*
*/
protected IContributionItem[] createContributionItemsForGroup(IRosterGroup group) {
Collection entries = group.getEntries();
MenuManager menuManager = null;
for (Iterator i = entries.iterator(); i.hasNext();) {
IRosterEntry entry = (IRosterEntry) i.next();
IContributionItem[] menuContributions = createContributionItemsForEntry(entry);
if (menuContributions != null && menuContributions.length > 0) {
for (int j = 0; j < menuContributions.length; j++) {
if (menuManager == null) {
menuManager = createMenuManagerForGroup(group);
}
menuManager.add(menuContributions[j]);
}
}
}
if (menuManager != null)
return new IContributionItem[] {menuManager};
return NO_CONTRIBUTIONS;
}
/**
* Create a MenuManager for the given {@link IRosterGroup}.
* @param group the IRosterGroup to create the menu manager for. Will not be <code>null</code>.
* @return the menu manager. Should not be <code>null</code>.
*/
protected MenuManager createMenuManagerForGroup(IRosterGroup group) {
return new MenuManager(group.getName());
// XXX 3.4 constructor return new MenuManager(group.getName(), SharedImages.getImageDescriptor(SharedImages.IMG_GROUP), null);
}
/**
* Create contribution items for a given presence container adapter. Subclasses may override as
* appropriate to customize the creation of contributions with an alternative strategy.
* @param presenceContainerAdapter the IPresenceContainerAdapter to create contribution items for. Must not be <code>null</code>.
* @return IContributionItem[] for given IPresenceContainerAdapter. Will not return <code>null</code>.
*
*/
protected IContributionItem[] createContributionItemsForPresenceContainer(IPresenceContainerAdapter presenceContainerAdapter) {
IRoster roster = presenceContainerAdapter.getRosterManager().getRoster();
IContributionItem[] contributions = createContributionItemsForRoster(roster);
if (contributions == null || contributions.length == 0)
return NO_CONTRIBUTIONS;
MenuManager menuManager = createMenuManagerForRoster(roster);
for (int i = 0; i < contributions.length; i++) {
menuManager.add(contributions[i]);
}
return new IContributionItem[] {menuManager};
}
/**
* Create a MenuManager for the given {@link IRosterGroup}.
* @param roster the IRosterGroup to create the menu manager for. Will not be <code>null</code>.
* @return the menu manager. Should not be <code>null</code>.
*/
protected MenuManager createMenuManagerForRoster(IRoster roster) {
// 3.4 constructor return new MenuManager(roster.getUser().getName(), SharedImages.getImageDescriptor(SharedImages.IMG_IDENTITY), null);
return new MenuManager(roster.getUser().getName());
}
private int getNextCommandIdIndex() {
return commandIdIndex++;
}
/**
* Create a {@link AbstractRosterMenuHandler} for a given IRosterEntry instance. Implementers of this method
* should construct and return a new {@link AbstractRosterMenuHandler}. When a menu selection is made for
* a given {@link IRosterEntry} menu item, the associated {@link AbstractRosterMenuHandler} instance will have its
* {@link AbstractRosterMenuHandler#execute(org.eclipse.core.commands.ExecutionEvent)} method will
* be called. This way, subclasses may define arbitrary behavior for the dynamic menu item
* selection.
*
* @param rosterEntry the {@link IRosterEntry} for the {@link AbstractRosterMenuHandler}. Will not be <code>null</code>.
* @return {@link AbstractRosterMenuHandler} instance. Must not be <code>null</code>.
*/
protected abstract AbstractRosterMenuHandler createRosterEntryHandler(IRosterEntry rosterEntry);
/**
* Determines whether given entry should be added for IContribution. This implementation only
* returns <code>true</code> if the given {@link IRosterEntry#getPresence()} IPresence.Type is
* AVAILABLE, and IPresence.Mode is AVAILABLE. Subclasses may override as appropriate
* to customize the behavior of this contribution item.
*
* @param entry the IRosterEntry to check. Must not be <code>null</code>.
* @return <code>true</code> if the given IRosterEntry should be added, <code>false</code> otherwise.
*/
protected boolean addEntry(IRosterEntry entry) {
IPresence presence = entry.getPresence();
if (presence == null)
return false;
return (presence.getType().equals(IPresence.Type.AVAILABLE) && presence.getMode().equals(IPresence.Mode.AVAILABLE));
}
/**
* Create contribution items for a given roster entry. Subclasses may override as
* appropriate to customize the creation of contributions with an alternative strategy.
* @param entry the IRosterEntry to create contribution items for. Must not be <code>null</code>.
* @return IContributionItem[] for given IPresenceContainerAdapter. Will not return <code>null</code>.
*
*/
protected IContributionItem[] createContributionItemsForEntry(IRosterEntry entry) {
if (addEntry(entry)) {
String commandId = ROSTERCOMMAND_PREFIX + getNextCommandIdIndex();
// Get existing/new command
Command command = commandService.getCommand(commandId);
command.define(commandId, null, commandService.getCategory(commandId + ".c")); //$NON-NLS-1$
IHandler handler = command.getHandler();
// Only mess with it if it was of old type
if (handler != null && handler instanceof AbstractRosterMenuHandler) {
AbstractRosterMenuHandler drh = (AbstractRosterMenuHandler) handler;
if (drh != null) {
drh.fireHandlerChangeEvent();
drh.dispose();
}
}
IHandler newHandler = createRosterEntryHandler(entry);
command.setHandler(newHandler);
handlerActivations.add(handlerService.activateHandler(commandId, newHandler));
return new IContributionItem[] {createCommandContributionItemForEntry(commandId, entry)};
}
return NO_CONTRIBUTIONS;
}
protected ImageDescriptor getRosterEntryImageDescriptor(IRosterEntry entry) {
IPresence p = entry.getPresence();
if (p != null) {
IPresence.Type pType = p.getType();
IPresence.Mode pMode = p.getMode();
// If type is unavailable then we're unavailable
if (pType.equals(IPresence.Type.AVAILABLE)) {
// if type and mode are both 'available' then we're actually
// available
if (pMode.equals(IPresence.Mode.AVAILABLE))
return SharedImages.getImageDescriptor(SharedImages.IMG_USER_AVAILABLE);
// If mode is away then we're away
else if (pMode.equals(IPresence.Mode.AWAY) || pMode.equals(IPresence.Mode.EXTENDED_AWAY))
return SharedImages.getImageDescriptor(SharedImages.IMG_USER_AWAY);
else if (pMode.equals(IPresence.Mode.DND))
return SharedImages.getImageDescriptor(SharedImages.IMG_USER_DND);
}
}
return SharedImages.getImageDescriptor(SharedImages.IMG_USER_UNAVAILABLE);
}
/**
* Create a command contribution item for the given entry with the given commandId.
*
* @param commandId the commandId for the new CommandContributionItem. Must not be <code>null</code>.
* @param rosterEntry the IRosterEntry for the new CommandContributionItem. Must not be <code>null</code>.
* @return CommandContributionItem created. Must not return <code>null</code>.
*/
protected CommandContributionItem createCommandContributionItemForEntry(String commandId, IRosterEntry rosterEntry) {
CommandContributionItemParameter p = new CommandContributionItemParameter(serviceLocator, null, commandId, CommandContributionItem.STYLE_PUSH);
p.icon = getRosterEntryImageDescriptor(rosterEntry);
p.label = rosterEntry.getName();
// 3.4 return new CommandContributionItem(serviceLocator, null, commandId, new HashMap(), getRosterEntryImageDescriptor(rosterEntry), null, null, rosterEntry.getName(), null, null, CommandContributionItem.STYLE_PUSH);
return new CommandContributionItem(p);
}
/* (non-Javadoc)
* @see org.eclipse.jface.action.ContributionItem#dispose()
*/
public void dispose() {
super.dispose();
if (handlerService != null) {
handlerService.deactivateHandlers(handlerActivations);
handlerService = null;
}
handlerActivations.clear();
commandService = null;
}
protected List getPresenceContainerAdapters() {
List presenceContainers = new ArrayList();
IContainerManager containerManager = Activator.getDefault().getContainerManager();
if (containerManager == null)
return presenceContainers;
IContainer[] containers = containerManager.getAllContainers();
for (int i = 0; i < containers.length; i++) {
IPresenceContainerAdapter presenceContainerAdapter = (IPresenceContainerAdapter) containers[i].getAdapter(IPresenceContainerAdapter.class);
if ((containers[i].getConnectedID() != null) && (presenceContainerAdapter != null)) {
presenceContainers.add(presenceContainerAdapter);
}
}
return presenceContainers;
}
/* (non-Javadoc)
* @see org.eclipse.ui.actions.CompoundContributionItem#getContributionItems()
*/
protected IContributionItem[] getContributionItems() {
// clearOldContributions();
List presenceContainers = getPresenceContainerAdapters();
if (presenceContainers.size() == 0)
return NO_CONTRIBUTIONS;
List contributions = new ArrayList();
for (Iterator i = presenceContainers.iterator(); i.hasNext();) {
IContributionItem[] items = createContributionItemsForPresenceContainer((IPresenceContainerAdapter) i.next());
for (int j = 0; j < items.length; j++)
contributions.add(items[j]);
}
if (contributions.size() > 0) {
MenuManager menuManager = createMenuManagerForTop();
IContributionItem[] items = (IContributionItem[]) contributions.toArray(new IContributionItem[] {});
for (int i = 0; i < items.length; i++)
menuManager.add(items[i]);
return new IContributionItem[] {new Separator(), menuManager};
}
return NO_CONTRIBUTIONS;
}
/**
* Create a MenuManager for the top level menu.
* @return the menu manager. Should not be <code>null</code>.
*/
protected MenuManager createMenuManagerForTop() {
// XXX 3.4 constructor return new MenuManager(topMenuName, topMenuImageDescriptor, null);
return new MenuManager(topMenuName);
}
}