diff --git a/examples/org.eclipse.e4.ui.deeplink.example.client/.classpath b/examples/org.eclipse.e4.ui.deeplink.example.client/.classpath
new file mode 100644
index 0000000..8a8f166
--- /dev/null
+++ b/examples/org.eclipse.e4.ui.deeplink.example.client/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/examples/org.eclipse.e4.ui.deeplink.example.client/.project b/examples/org.eclipse.e4.ui.deeplink.example.client/.project
new file mode 100644
index 0000000..6ecf510
--- /dev/null
+++ b/examples/org.eclipse.e4.ui.deeplink.example.client/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.e4.ui.deeplink.example.client</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/examples/org.eclipse.e4.ui.deeplink.example.client/.settings/org.eclipse.jdt.core.prefs b/examples/org.eclipse.e4.ui.deeplink.example.client/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..8cd21ef
--- /dev/null
+++ b/examples/org.eclipse.e4.ui.deeplink.example.client/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,7 @@
+#Wed Feb 24 17:30:23 GMT 2010
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.6
diff --git a/examples/org.eclipse.e4.ui.deeplink.example.client/META-INF/MANIFEST.MF b/examples/org.eclipse.e4.ui.deeplink.example.client/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..b26801a
--- /dev/null
+++ b/examples/org.eclipse.e4.ui.deeplink.example.client/META-INF/MANIFEST.MF
@@ -0,0 +1,13 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: Client2 Plug-in
+Bundle-SymbolicName: org.eclipse.e4.ui.deeplink.example.client;singleton:=true
+Bundle-Version: 4.6.0.qualifier
+Bundle-Activator: org.eclipse.e4.ui.deeplink.example.client.Activator
+Require-Bundle: org.eclipse.ui,
+ org.eclipse.core.runtime,
+ org.eclipse.e4.core.deeplink;bundle-version="4.5.0",
+ org.eclipse.e4.core.deeplink.handler;bundle-version="4.5.0",
+ org.eclipse.e4.core.deeplink.typehandler.extensionpt;bundle-version="1.0.0"
+Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-ActivationPolicy: lazy
diff --git a/examples/org.eclipse.e4.ui.deeplink.example.client/about.html b/examples/org.eclipse.e4.ui.deeplink.example.client/about.html
new file mode 100644
index 0000000..f77f378
--- /dev/null
+++ b/examples/org.eclipse.e4.ui.deeplink.example.client/about.html
@@ -0,0 +1,22 @@
+<h1>About This Content</h1>
+
+23 June, 2010
+
+<h2>License</h2>
+
+<p>The Eclipse Foundation makes available all content in this plug-in
+("Content"). Unless otherwise indicated below, the Content is provided
+to you under the terms and conditions of the Eclipse Public License
+Version 1.0 ("EPL"). A copy of the EPL is available at
+http://www.eclipse.org/legal/epl-v10.html. For purposes of the EPL,
+"Program" will mean the Content.</p>
+
+<p>If you did not receive this Content directly from the Eclipse
+Foundation, the Content is being redistributed by another party
+("Redistributor") and different terms and conditions may apply to your
+use of any object code in the Content. Check the Redistributor’s
+license that was provided with the Content. If no such license exists,
+contact the Redistributor. Unless otherwise indicated below, the terms
+and conditions of the EPL still apply to any source code in the
+Content and such source code may be obtained at
+http://www.eclipse.org.</p>
diff --git a/examples/org.eclipse.e4.ui.deeplink.example.client/build.properties b/examples/org.eclipse.e4.ui.deeplink.example.client/build.properties
new file mode 100644
index 0000000..50ca378
--- /dev/null
+++ b/examples/org.eclipse.e4.ui.deeplink.example.client/build.properties
@@ -0,0 +1,7 @@
+source.. = src/
+output.. = bin/
+bin.includes = plugin.xml,\
+               META-INF/,\
+               .,\
+               icons/,\
+               splash.bmp
diff --git a/examples/org.eclipse.e4.ui.deeplink.example.client/plugin.xml b/examples/org.eclipse.e4.ui.deeplink.example.client/plugin.xml
new file mode 100644
index 0000000..1a834e7
--- /dev/null
+++ b/examples/org.eclipse.e4.ui.deeplink.example.client/plugin.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.4"?>
+<plugin>
+
+   <extension
+         id="application"
+         point="org.eclipse.core.runtime.applications">
+      <application>
+         <run
+               class="org.eclipse.e4.ui.deeplink.example.client.Application">
+         </run>
+      </application>
+   </extension>
+   <extension
+         id="product"
+         point="org.eclipse.core.runtime.products">
+      <product
+            application="org.eclipse.e4.ui.deeplink.example.client.application"
+            name="Deeplink Example Product">
+         <property
+               name="appName"
+               value="Deeplink Example Product">
+         </property>
+      </product>
+   </extension>
+   <extension
+         point="org.eclipse.e4.core.deeplink.typehandler.extensionpt.deepLinkExtensionPointInstanceHandler">
+      <deepLinkExtensionPointInstanceHandler
+            class="org.eclipse.e4.ui.deeplink.example.client.SayHelloHandler"
+            id="sayhello">
+      </deepLinkExtensionPointInstanceHandler>
+   </extension>
+
+</plugin>
diff --git a/examples/org.eclipse.e4.ui.deeplink.example.client/src/org/eclipse/e4/ui/deeplink/example/client/Activator.java b/examples/org.eclipse.e4.ui.deeplink.example.client/src/org/eclipse/e4/ui/deeplink/example/client/Activator.java
new file mode 100644
index 0000000..705acee
--- /dev/null
+++ b/examples/org.eclipse.e4.ui.deeplink.example.client/src/org/eclipse/e4/ui/deeplink/example/client/Activator.java
@@ -0,0 +1,62 @@
+/******************************************************************************
+ * Copyright (c) David Orme 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:
+ *    David Orme - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.e4.ui.deeplink.example.client;
+
+import org.eclipse.ui.plugin.AbstractUIPlugin;
+import org.osgi.framework.BundleContext;
+
+
+
+public class Activator extends AbstractUIPlugin {
+//	private static final String CONFIG_TRACKER_CLASSNAME = Configuration.class.getName();
+	
+	// The shared instance
+	private static Activator plugin;
+
+	public Activator() {
+	}
+
+	@Override
+	public void start(BundleContext context) throws Exception {
+		super.start(context);
+//		configTracker = new ServiceTracker(context, CONFIG_TRACKER_CLASSNAME, null);
+//		configTracker.open();
+		plugin = this;
+	}
+	
+	@Override
+	public void stop(BundleContext context) throws Exception {
+		super.stop(context);
+	}
+
+	/**
+	 * Returns the shared instance
+	 * 
+	 * @return the shared instance
+	 */
+	public static Activator getDefault() {
+		return plugin;
+	}
+	
+	/**
+	 * @return the current configuration file's Properties object. May be null
+	 *         if the configuration service is not loaded or is not included in
+	 *         the application.
+	 */
+//	public Configuration getConfiguration() {
+//		Configuration configuration = (Configuration) configTracker.getService();
+//		if (null == configuration)
+//		{
+//			throw new ConfigurationException("Null config service: no service registered for :[" + CONFIG_TRACKER_CLASSNAME + "]");				
+//		}
+//		return configuration;
+//	}	
+}
\ No newline at end of file
diff --git a/examples/org.eclipse.e4.ui.deeplink.example.client/src/org/eclipse/e4/ui/deeplink/example/client/Application.java b/examples/org.eclipse.e4.ui.deeplink.example.client/src/org/eclipse/e4/ui/deeplink/example/client/Application.java
new file mode 100644
index 0000000..066f65c
--- /dev/null
+++ b/examples/org.eclipse.e4.ui.deeplink.example.client/src/org/eclipse/e4/ui/deeplink/example/client/Application.java
@@ -0,0 +1,73 @@
+/******************************************************************************
+ * Copyright (c) David Orme 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:
+ *    David Orme - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.e4.ui.deeplink.example.client;
+
+import org.eclipse.e4.core.deeplink.DeepLinkManager;
+import org.eclipse.equinox.app.IApplication;
+import org.eclipse.equinox.app.IApplicationContext;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.ui.IWorkbench;
+import org.eclipse.ui.PlatformUI;
+
+
+/**
+ * This class controls all aspects of the application's execution
+ */
+public class Application implements IApplication {
+
+	private static final int ONE_SECOND = 1000;
+	private final String COMMANDLINE_KEY = "application.args";
+	private Thread updateThread;
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.equinox.app.IApplication#start(org.eclipse.equinox.app.IApplicationContext)
+	 */
+	public Object start(IApplicationContext context) throws Exception {
+		Display display = PlatformUI.createDisplay();
+				
+		// Include the following code and add org.eclipse.e4.core.deeplink
+		// as a dependency if you intend to support deeplinking
+		DeepLinkManager deepLinkManager = new DeepLinkManager(true, Activator.getDefault().getLog());
+		deepLinkManager.startServer();
+		deepLinkManager.processCommandLineArguments(context);
+		
+		try {
+			int returnCode = PlatformUI.createAndRunWorkbench(display, new ApplicationWorkbenchAdvisor());
+			if (returnCode == PlatformUI.RETURN_RESTART)
+				return IApplication.EXIT_RESTART;
+			else
+				return IApplication.EXIT_OK;
+		} finally {
+			display.dispose();
+		}
+		
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.equinox.app.IApplication#stop()
+	 */
+	public void stop() {
+		final IWorkbench workbench = PlatformUI.getWorkbench();
+		if (workbench == null)
+			return;
+		final Display display = workbench.getDisplay();
+		display.syncExec(new Runnable() {
+			public void run() {
+				if (!display.isDisposed())
+					workbench.close();
+			}
+		});
+		
+		if (updateThread != null) {
+			updateThread.interrupt();
+		}
+	}
+}
\ No newline at end of file
diff --git a/examples/org.eclipse.e4.ui.deeplink.example.client/src/org/eclipse/e4/ui/deeplink/example/client/ApplicationActionBarAdvisor.java b/examples/org.eclipse.e4.ui.deeplink.example.client/src/org/eclipse/e4/ui/deeplink/example/client/ApplicationActionBarAdvisor.java
new file mode 100644
index 0000000..c4ccc07
--- /dev/null
+++ b/examples/org.eclipse.e4.ui.deeplink.example.client/src/org/eclipse/e4/ui/deeplink/example/client/ApplicationActionBarAdvisor.java
@@ -0,0 +1,157 @@
+/******************************************************************************
+ * Copyright (c) David Orme 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:
+ *    David Orme - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.e4.ui.deeplink.example.client;
+
+import org.eclipse.jface.action.GroupMarker;
+import org.eclipse.jface.action.IMenuManager;
+import org.eclipse.jface.action.MenuManager;
+import org.eclipse.jface.action.Separator;
+import org.eclipse.ui.IWorkbenchActionConstants;
+import org.eclipse.ui.IWorkbenchWindow;
+import org.eclipse.ui.actions.ActionFactory;
+import org.eclipse.ui.actions.ActionFactory.IWorkbenchAction;
+import org.eclipse.ui.application.ActionBarAdvisor;
+import org.eclipse.ui.application.IActionBarConfigurer;
+
+public class ApplicationActionBarAdvisor extends ActionBarAdvisor {
+
+	private final IWorkbenchWindow workbenchWindow;
+	
+	private IWorkbenchAction quitAction;
+	private IWorkbenchAction openPreferencesAction;
+	private IWorkbenchAction newWindowAction;
+	private IWorkbenchAction resetPerspectiveAction;
+	private IWorkbenchAction introAction;
+	private IWorkbenchAction aboutAction;
+	private IWorkbenchAction showViewMenuAction;
+    private IWorkbenchAction showHelpAction; // NEW
+    private IWorkbenchAction searchHelpAction; // NEW
+    private IWorkbenchAction dynamicHelpAction; // NEW
+
+    public ApplicationActionBarAdvisor(IActionBarConfigurer configurer) {
+        super(configurer);
+        workbenchWindow = configurer.getWindowConfigurer().getWindow();
+    }
+
+    protected void makeActions(IWorkbenchWindow window) {
+		quitAction = ActionFactory.QUIT.create(window);
+		register(quitAction);
+
+    	openPreferencesAction = ActionFactory.PREFERENCES.create(window);
+		register(openPreferencesAction);
+    	
+		newWindowAction = ActionFactory.OPEN_NEW_WINDOW.create(workbenchWindow);
+		newWindowAction.setText("&New Window");
+		register(newWindowAction);
+    	
+		resetPerspectiveAction = ActionFactory.RESET_PERSPECTIVE.create(window);
+		resetPerspectiveAction.setText("Reset Window");
+		register(resetPerspectiveAction);
+		
+		if (window.getWorkbench().getIntroManager().hasIntro()) {
+			introAction = ActionFactory.INTRO.create(window);
+			register(introAction);
+		}
+		
+		aboutAction = ActionFactory.ABOUT.create(window);
+		register(aboutAction);
+		
+		showViewMenuAction = ActionFactory.SHOW_VIEW_MENU.create(window);
+		register(showViewMenuAction);
+
+	    showHelpAction = ActionFactory.HELP_CONTENTS.create(window); // NEW
+	    register(showHelpAction); // NEW
+
+	    searchHelpAction = ActionFactory.HELP_SEARCH.create(window); // NEW
+	    register(searchHelpAction); // NEW
+
+	    dynamicHelpAction = ActionFactory.DYNAMIC_HELP.create(window); // NEW
+	    register(dynamicHelpAction); // NEW
+	}
+
+    protected void fillMenuBar(IMenuManager menuBar) {
+		menuBar.add(createFileMenu());    	
+		menuBar.add(createWindowMenu());
+		menuBar.add(createHelpMenu());
+
+    }
+    
+	/**
+	 * Creates and returns the File menu.
+	 */
+	private MenuManager createFileMenu() {
+		MenuManager menu = new MenuManager("&File", IWorkbenchActionConstants.M_FILE);
+		menu.add(new Separator());
+		menu.add(quitAction);
+		menu.add(new GroupMarker(IWorkbenchActionConstants.FILE_END));
+		return menu;
+	}    
+	/**
+	 * Creates and returns the Window menu.
+	 */
+	private MenuManager createWindowMenu() {
+		final MenuManager menu = new MenuManager("&Window",
+				IWorkbenchActionConstants.M_WINDOW);
+		menu.add(newWindowAction);
+
+		menu.add(resetPerspectiveAction);
+		menu.add(new Separator());
+
+		menu.add(showViewMenuAction);
+		
+		menu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS + "end")); //NON-NLS-1
+		
+		menu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
+		menu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS + "end")); //NON-NLS-1
+		menu.add(openPreferencesAction);
+		
+		return menu;
+	}
+
+	/**
+	 * Creates and returns the Help menu.
+	 */
+	private MenuManager createHelpMenu() {
+		MenuManager menu = new MenuManager("&Help",
+				IWorkbenchActionConstants.M_HELP);
+		addSeparatorOrGroupMarker(menu, "group.intro"); // NON-NLS-1
+		// See if a welcome or intro page is specified
+		if (introAction != null) {
+			menu.add(introAction);
+		}
+		menu.add(new GroupMarker("group.intro.ext")); // NON-NLS-1
+		menu.add(new Separator("group.about")); // NON-NLS-1
+		menu.add(aboutAction);
+		menu.add(new GroupMarker("group.about.ext")); // NON-NLS-1
+
+		menu.add(showHelpAction); // NEW
+		menu.add(searchHelpAction); // NEW
+		menu.add(dynamicHelpAction); // NEW
+
+		return menu;
+	}
+	
+	/**
+	 * Adds a <code>GroupMarker</code> or <code>Separator</code> to a menu.
+	 * The test for whether a separator should be added is done by checking for
+	 * the existence of a preference matching the string
+	 * useSeparator.MENUID.GROUPID that is set to <code>true</code>.
+	 * 
+	 * @param menu
+	 *            the menu to add to
+	 * @param groupId
+	 *            the group id for the added separator or group marker
+	 */
+	private void addSeparatorOrGroupMarker(MenuManager menu, String groupId) {
+		String prefId = "useSeparator." + menu.getId() + "." + groupId; //NON-NLS-1 //NON-NLS-2
+		menu.add(new GroupMarker(groupId));
+	}
+}
\ No newline at end of file
diff --git a/examples/org.eclipse.e4.ui.deeplink.example.client/src/org/eclipse/e4/ui/deeplink/example/client/ApplicationWorkbenchAdvisor.java b/examples/org.eclipse.e4.ui.deeplink.example.client/src/org/eclipse/e4/ui/deeplink/example/client/ApplicationWorkbenchAdvisor.java
new file mode 100644
index 0000000..4b57443
--- /dev/null
+++ b/examples/org.eclipse.e4.ui.deeplink.example.client/src/org/eclipse/e4/ui/deeplink/example/client/ApplicationWorkbenchAdvisor.java
@@ -0,0 +1,36 @@
+/******************************************************************************
+ * Copyright (c) David Orme 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:
+ *    David Orme - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.e4.ui.deeplink.example.client;
+
+import org.eclipse.ui.application.IWorkbenchConfigurer;
+import org.eclipse.ui.application.IWorkbenchWindowConfigurer;
+import org.eclipse.ui.application.WorkbenchAdvisor;
+import org.eclipse.ui.application.WorkbenchWindowAdvisor;
+
+
+public class ApplicationWorkbenchAdvisor extends WorkbenchAdvisor {
+
+    private static final String INITIAL_PERSPECTIVE_ID = "org.eclipse.e4.enterprise.deeplink.example.client.ui.perspective2";
+
+	public WorkbenchWindowAdvisor createWorkbenchWindowAdvisor(IWorkbenchWindowConfigurer configurer) {
+        return new ApplicationWorkbenchWindowAdvisor(configurer);
+    }
+
+	public void initialize(IWorkbenchConfigurer configurer) {
+		super.initialize(configurer);
+		configurer.setSaveAndRestore(true);
+	}
+
+	public String getInitialWindowPerspectiveId() {
+		return INITIAL_PERSPECTIVE_ID;
+	}
+
+}
diff --git a/examples/org.eclipse.e4.ui.deeplink.example.client/src/org/eclipse/e4/ui/deeplink/example/client/ApplicationWorkbenchWindowAdvisor.java b/examples/org.eclipse.e4.ui.deeplink.example.client/src/org/eclipse/e4/ui/deeplink/example/client/ApplicationWorkbenchWindowAdvisor.java
new file mode 100644
index 0000000..33c014a
--- /dev/null
+++ b/examples/org.eclipse.e4.ui.deeplink.example.client/src/org/eclipse/e4/ui/deeplink/example/client/ApplicationWorkbenchWindowAdvisor.java
@@ -0,0 +1,41 @@
+/******************************************************************************
+ * Copyright (c) David Orme 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:
+ *    David Orme - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.e4.ui.deeplink.example.client;
+
+import org.eclipse.ui.application.ActionBarAdvisor;
+import org.eclipse.ui.application.IActionBarConfigurer;
+import org.eclipse.ui.application.IWorkbenchWindowConfigurer;
+import org.eclipse.ui.application.WorkbenchWindowAdvisor;
+
+public class ApplicationWorkbenchWindowAdvisor extends WorkbenchWindowAdvisor {
+
+    public ApplicationWorkbenchWindowAdvisor(IWorkbenchWindowConfigurer configurer) {
+        super(configurer);
+    }
+
+    public ActionBarAdvisor createActionBarAdvisor(IActionBarConfigurer configurer) {
+        return new ApplicationActionBarAdvisor(configurer);
+    }
+    
+    public void preWindowOpen() {
+        IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
+        
+        //this is all standard RCP so just display the elements
+        //you want and hide the rest
+        configurer.setShowCoolBar(true);
+        configurer.setShowStatusLine(true);
+        configurer.setShowFastViewBars(true);
+        configurer.setShowMenuBar(true);
+        configurer.setShowPerspectiveBar(true);
+        configurer.setShowProgressIndicator(true);
+        
+    }
+}
diff --git a/examples/org.eclipse.e4.ui.deeplink.example.client/src/org/eclipse/e4/ui/deeplink/example/client/SayHelloHandler.java b/examples/org.eclipse.e4.ui.deeplink.example.client/src/org/eclipse/e4/ui/deeplink/example/client/SayHelloHandler.java
new file mode 100644
index 0000000..21e9d83
--- /dev/null
+++ b/examples/org.eclipse.e4.ui.deeplink.example.client/src/org/eclipse/e4/ui/deeplink/example/client/SayHelloHandler.java
@@ -0,0 +1,32 @@
+/******************************************************************************
+ * Copyright (c) David Orme 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:
+ *    David Orme - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.e4.ui.deeplink.example.client;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.eclipse.e4.core.deeplink.api.AbstractDeepLinkInstanceHandler;
+
+
+/**
+ * A simple deeplink callback handler that is registered via extension point. 
+ */
+public class SayHelloHandler extends AbstractDeepLinkInstanceHandler {
+	
+	@Override
+	public Map<String, String> activate(String handlerInstanceID, String action, Map<String, String[]> params) {
+		Map<String, String> results = new HashMap<String, String>();
+		String helloMessage = "Hello, " + action;
+		System.out.println(helloMessage);
+		results.put("Hello", helloMessage);
+		return results;
+	}
+}
