ICommandService cmdService = (ICommandService) getSite().getService(
    ICommandService.class);
Category lunch = cmdService
    .getCategory("z.ex.view.keybindings.category");
if (!lunch.isDefined()) {
  lunch.define("Lunch", "Actions take at lunch time.");
}
Command eatTaco = cmdService
    .getCommand("z.ex.view.keybindings.eatTaco");
if (!eatTaco.isDefined()) {
  eatTaco.define("Eat That Taco", "Go for the taco.", lunch);
}

 		ICommandService commandService = ...;
 		IHandlerService handlerService = ...;
 		Command showView = commandService
 				.getCommand("org.eclipse.ui.views.showView");
 		IParameter viewIdParm = showView
 				.getParameter("org.eclipse.ui.views.showView.viewId");
 
 		// the viewId parameter provides a list of valid values ... if you
 		// knew the id of the problem view, you could skip this step.
 		// This method is supposed to be used in places like the keys
 		// preference page, to allow the user to select values
 		IParameterValues parmValues = viewIdParm.getValues();
 		String viewId = null;
 		Iterator i = parmValues.getParameterValues().values().iterator();
 		while (i.hasNext()) {
 			String id = (String) i.next();
 			if (id.indexOf("ProblemView") != -1) {
 				viewId = id;
 				break;
 			}
 		}
 
 		Parameterization parm = new Parameterization(viewIdParm, viewId);
 		ParameterizedCommand parmCommand = new ParameterizedCommand(
 				showView, new Parameterization[] { parm });
 
 		handlerService.executeCommand(parmCommand, null);

 /*******************************************************************************
  * Copyright (c) 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 API and implementation
  *******************************************************************************/
 package org.eclipse.ui.tests.api;
 
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.Map;
 
 import org.eclipse.core.commands.Command;
 import org.eclipse.core.commands.IParameter;
 import org.eclipse.core.commands.Parameterization;
 import org.eclipse.core.commands.ParameterizedCommand;
 import org.eclipse.core.commands.common.NotDefinedException;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IConfigurationElement;
 import org.eclipse.core.runtime.IExecutableExtension;
 import org.eclipse.jface.action.IAction;
 import org.eclipse.jface.viewers.ISelection;
 import org.eclipse.ui.IEditorActionDelegate;
 import org.eclipse.ui.IEditorPart;
 import org.eclipse.ui.IObjectActionDelegate;
 import org.eclipse.ui.IViewActionDelegate;
 import org.eclipse.ui.IViewPart;
 import org.eclipse.ui.IWorkbenchPart;
 import org.eclipse.ui.IWorkbenchWindow;
 import org.eclipse.ui.IWorkbenchWindowActionDelegate;
 import org.eclipse.ui.commands.ICommandService;
 import org.eclipse.ui.handlers.IHandlerService;
 
 /**
  * This action delegate can be used to specify a command with or without
  * parameters be called from an <action/> specified in actionSets,
  * editorActions, viewActions, or popupMenus.
  */
 public class GenericCommandActionDelegate implements
         IWorkbenchWindowActionDelegate, IViewActionDelegate,
         IEditorActionDelegate, IObjectActionDelegate, IExecutableExtension {
 
     private static final String PARM_COMMAND_ID = "commandId";
 
     private String commandId = null;
 
     private Map parameterMap = null;
 
     private ParameterizedCommand parameterizedCommand = null;
 
     private IHandlerService handlerService = null;
 
     @Override 
     public void dispose() {
         handlerService = null;
         parameterizedCommand = null;
         parameterMap = null;
     }
 
     @Override 
     public void run(IAction action) {
         if (handlerService == null) {
             // what, no handler service ... no problem
             return;
         }
         try {
             if (commandId != null) {
                 handlerService.executeCommand(commandId, null);
             } else if (parameterizedCommand != null) {
                 handlerService.executeCommand(parameterizedCommand, null);
             }
             // else there is no command for this delegate
         } catch (Exception e) {
             // exceptions reduced for brevity
             // and we won't just do a print out :-)
         }
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see org.eclipse.ui.IActionDelegate#selectionChanged(org.eclipse.jface.action.IAction,
      *      org.eclipse.jface.viewers.ISelection)
      */
     public void selectionChanged(IAction action, ISelection selection) {
         // we don't care, handlers get their selection from the
         // ExecutionEvent application context
     }
 
     @Override 
     public void setInitializationData(IConfigurationElement config,
             String propertyName, Object data) throws CoreException {
         String id = config.getAttribute(IWorkbenchRegistryConstants.ATT_ID);
         // save the data until our init(*) call, where we can get
         // the services.
         if (data instanceof String) {
             commandId = (String) data;
         } else if (data instanceof Map) {
             parameterMap = (Map) data;
             if (parameterMap.get(PARM_COMMAND_ID) == null) {
                 Status status = new Status(IStatus.ERROR,
                         "org.eclipse.ui.tests", "The '" + id
                                 + "' action won't work without a commandId");
                 throw new CoreException(status);
             }
         } else {
             Status status = new Status(
                     IStatus.ERROR,
                     "org.eclipse.ui.tests",
                     "The '"
                             + id
                             + "' action won't work without some initialization parameters");
             throw new CoreException(status);
         }
     }
 
     /**
      * Build a command from the executable extension information.
      * 
      * @param commandService
      *            to get the Command object
      */
     private void createCommand(ICommandService commandService) {
         String id = (String) parameterMap.get(PARM_COMMAND_ID);
         if (id == null) {
             return;
         }
         if (parameterMap.size() == 1) {
             commandId = id;
             return;
         }
         try {
             Command cmd = commandService.getCommand(id);
             if (!cmd.isDefined()) {
                 // command not defined? no problem ...
                 return;
             }
             ArrayList parameters = new ArrayList();
             Iterator i = parameterMap.entrySet().iterator();
             while (i.hasNext()) {
                 Map.Entry entry = (Map.Entry) i.next();
                 String parmName = (String) entry.getKey();
                 if (PARM_COMMAND_ID.equals(parmName)) {
                     continue;
                 }
                 IParameter parm = cmd.getParameter(parmName);
                 if (parm == null) {
                     // asking for a bogus parameter? No problem
                     return;
                 }
                 parameters.add(new Parameterization(parm, (String) entry.getValue()));
             }
             parameterizedCommand = new ParameterizedCommand(cmd,
                     (Parameterization[]) parameters
                             .toArray(new Parameterization[parameters.size()]));
         } catch (NotDefinedException e) {
             // command is bogus? No problem, we'll do nothing.
         }
     }
 
     @Override 
     public void init(IWorkbenchWindow window) {
         if (handlerService != null) {
             // already initialized
             return;
         }
 
         handlerService = (IHandlerService) window
                 .getService(IHandlerService.class);
         if (parameterMap != null) {
             ICommandService commandService = (ICommandService) window
                     .getService(ICommandService.class);
             createCommand(commandService);
         }
     }
 
     @Override 
     public void init(IViewPart view) {
         init(view.getSite().getWorkbenchWindow());
     }
 
     @Override 
     public void setActiveEditor(IAction action, IEditorPart targetEditor) {
         // we don't actually care about the active editor, since that
         // information is in the ExecutionEvent application context
         // but we need to make sure we're initialized.
         if (targetEditor != null) {
             init(targetEditor.getSite().getWorkbenchWindow());
         }
     }
 
     @Override 
     public void setActivePart(IAction action, IWorkbenchPart targetPart) {
         // we don't actually care about the active part, since that
         // information is in the ExecutionEvent application context
         // but we need to make sure we're initialized.
         if (targetPart != null) {
             init(targetPart.getSite().getWorkbenchWindow());
         }
     }
 }

IHandlerService handlerService = (IHandlerService) getSite()
    .getService(IHandlerService.class);
IHandler handler = new AbstractHandler() {
  public Object execute(ExecutionEvent event)
          throws ExecutionException {
    System.out.println("Eat that Taco");
    return null;
  }
};
handlerService
    .activateHandler("z.ex.view.keybindings.eatTaco", handler);

 handlerService.executeCommand("z.ex.view.keybindings.eatTaco", null);

Command eatTaco = cmdService
   .getCommand("z.ex.view.keybindings.eatTaco");
eatTaco.execute(new ExecutionEvent(Collections.EMPTY_MAP, null, handlerService.getCurrentState()));

Expression expr = new Expression() {
    public final EvaluationResult evaluate(final IEvaluationContext context) {
        Object sel = context.getVariable(ISources.ACTIVE_CURRENT_SELECTION_NAME);
        (return EvaluationResult.TRUE/FALSE depending on how much you like the selection)
    }
    public void collectExpressionInfo(final ExpressionInfo info) {
         // You need this to cause the expr to be evaluated on selection events
         info.markDefaultVariableAccessed();
    }
};

IContextService contextService = (IContextService) getSite()
  .getService(IContextService.class);
IContextActivation contextActivation = contextService.activateContext("z.ex.view.keybindings.contexts.taco");

Context tacos = contextService
    .getContext("z.ex.view.keybindings.contexts.taco");
if (!tacos.isDefined()) {
  tacos.define("Mexican Food", "To allow the consumption of Tacos",
      "org.eclipse.ui.contexts.window");
}