<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en" dir="ltr">
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
				<meta name="keywords" content="SMILA/BPEL Designer" />
		<link rel="shortcut icon" href="http://wiki.eclipse.org/SMILA/favicon.ico" />
		<link rel="search" type="application/opensearchdescription+xml" href="http://wiki.eclipse.org/opensearch_desc.php" title="Eclipsepedia (English)" />
<link rel="alternate" type="application/rss+xml" title="Eclipsepedia RSS Feed" href="http://wiki.eclipse.org/index.php?title=Special:Recentchanges&amp;feed=rss" />
<link rel="alternate" type="application/atom+xml" title="Eclipsepedia Atom Feed" href="http://wiki.eclipse.org/index.php?title=Special:Recentchanges&amp;feed=atom" />
	
		
		<title>SMILA/BPEL Designer - Eclipsepedia</title>

		<style type="text/css" media="screen,projection">/*<![CDATA[*/ @import "http://wiki.eclipse.org/skins/eclipsenova/novaWide.css?116"; /*]]>*/</style>
		<link rel="stylesheet" type="text/css" media="print" href="http://wiki.eclipse.org/skins/eclipsenova/eclipsenovaPrint.css?116" />
		<link rel="stylesheet" type="text/css" media="handheld" href="http://wiki.eclipse.org/skins/eclipsenova/handheld.css?116" />
		<link rel="stylesheet" type="text/css" href="http://wiki.eclipse.org/skins/eclipsenova/Nova/css/header.css" media="screen" />
		<link rel="stylesheet" type="text/css" href="http://wiki.eclipse.org/skins/eclipsenova/tabs.css" media="screen" />
		<link rel="stylesheet" type="text/css" href="http://wiki.eclipse.org/skins/eclipsenova/Nova/css/visual.css" media="screen" />
		<link rel="stylesheet" type="text/css" href="http://wiki.eclipse.org/skins/eclipsenova/Nova/css/layout.css" media="screen" />
		<link rel="stylesheet" type="text/css" href="http://wiki.eclipse.org/skins/eclipsenova/Nova/css/footer.css" media="screen" />
	        <!--[if IE]><link rel="stylesheet" type="text/css" href="/skins/eclipsenova/IEpngfix.css" media="screen" /><![endif]-->
		<!--[if lt IE 5.5000]><style type="text/css">@import "/skins/eclipsenova/IE50Fixes.css?116";</style> <![endif]-->
		<!--[if IE 5.5000]><style type="text/css">@import "/skins/eclipsenova/IE55Fixes.css?116";</style><![endif]-->
		<!--[if IE 6]><style type="text/css">@import "/skins/eclipsenova/IE60Fixes.css?116";</style><![endif]-->
		<!--[if IE 7]><style type="text/css">@import "/skins/eclipsenova/IE70Fixes.css?116";</style><![endif]-->
		<!--[if lt IE 7]><script type="text/javascript" src="/skins/common/IEFixes.js?116"></script>
		<meta http-equiv="imagetoolbar" content="no" /><![endif]-->
		<script type= "text/javascript">/*<![CDATA[*/
var skin = "eclipsenova";
var stylepath = "/skins";
var wgArticlePath = "/$1";
var wgScriptPath = "";
var wgScript = "/index.php";
var wgServer = "http://wiki.eclipse.org";
var wgCanonicalNamespace = "";
var wgCanonicalSpecialPageName = false;
var wgNamespaceNumber = 0;
var wgPageName = "SMILA/BPEL_Designer";
var wgTitle = "SMILA/BPEL Designer";
var wgAction = "view";
var wgRestrictionEdit = [];
var wgRestrictionMove = [];
var wgArticleId = "28933";
var wgIsArticle = true;
var wgUserName = null;
var wgUserGroups = null;
var wgUserLanguage = "en";
var wgContentLanguage = "en";
var wgBreakFrames = false;
var wgCurRevisionId = "293873";
var wgVersion = "1.12.0";
var wgEnableAPI = true;
var wgEnableWriteAPI = false;
/*]]>*/</script>
                
		<script type="text/javascript" src="http://wiki.eclipse.org/skins/common/wikibits.js?116"><!-- wikibits js --></script>

<!-- Performance mods similar to those for bug 166401 -->
		<script type="text/javascript" src="http://wiki.eclipse.org/index.php?title=-&amp;action=raw&amp;gen=js&amp;useskin=eclipsenova"><!-- site js --></script>

		<!-- Head Scripts -->
				<script type="text/javascript" src="http://wiki.eclipse.org/skins/common/ajax.js?116"></script>
<link rel="stylesheet" type="text/css" href="BPEL_Designer.html" />	</head>
<body  class="mediawiki ns-0 ltr page-SMILA_BPEL_Designer">
	<div id="globalWrapper">


		<div id="column-one">
<!-- Eclipse Additions for the Top Nav start here M. Ward-->

		      <div id="header">
               <div id="header-graphic">
                 <img src="http://wiki.eclipse.org/skins/eclipsenova/eclipse.png" alt="Eclipse Wiki">
               </div>
<!-- Pulled 101409 Mward	   -->
            
            <div class="portlet" id="p-personal">
              <div class="pBody">
              <ul>
                <li id="pt-login"><a href="http://wiki.eclipse.org/index.php?title=Special:Userlogin&amp;returnto=SMILA/BPEL_Designer">Log in</a></li>
                      </ul>
              </div>
            </div>

            <div id="header-icons">
	      <div id="sites">
              <ul id="sitesUL">
                <li><a href="http://www.eclipse.org"><img src="http://dev.eclipse.org/custom_icons/eclipseIcon.png" width="28" height="28" alt="Eclipse Foundation" title="Eclipse Foundation" /><div>Eclipse Foundation</div></a></li>
                <li><a href="http://marketplace.eclipse.org"><img src="http://dev.eclipse.org/custom_icons/marketplace.png" width="28" height="28" alt="Eclipse Marketplace" title="Eclipse Marketplace" /><div>Eclipse Marketplace</div></a></li>
                <li><a href="https://bugs.eclipse.org/bugs"><img src="http://dev.eclipse.org/custom_icons/system-search-bw.png" width="28" height="28" alt="Bugzilla" title="Bugzilla" /><div>Bugzilla</div></a></li>
                <li><a href="http://live.eclipse.org"><img src="http://dev.eclipse.org/custom_icons/audio-input-microphone-bw.png" width="28" height="28" alt="Live" title="Live" /><div>Eclipse Live</div></a></li>
                <li><a href="http://planeteclipse.org"><img src="http://dev.eclipse.org/large_icons/devices/audio-card.png" width="28" height="28" alt="PlanetEclipse" title="Planet" /><div>Planet Eclipse</div></a></li>
                <li><a href="http://portal.eclipse.org"><img src="http://dev.eclipse.org/custom_icons/preferences-system-network-proxy-bw.png" width="28" height="28" alt="Portal" title="Portal" /><div>My Foundation Portal</div></a></li>
              </ul>
              </div>
            </div>
        </div> 
<!-- NEW HEADER STUFF HERE -->
       <div id="header-menu">
         <div id="header-nav">
               <ul> 		 <li><a class="first_one" href="http://wiki.eclipse.org/" target="_self">Home</a></li>                  <li><a  href="http://www.eclipse.org/downloads/" target="_self">Downloads</a></li> 
                 <li><a  href="http://www.eclipse.org/users/" target="_self">Users</a></li> 
                 <li><a  href="http://www.eclipse.org/membership/" target="_self">Members</a></li> 
                 <li><a  href="http://wiki.eclipse.org/index.php/Development_Resources" target="_self">Committers</a></li> 
                 <li><a  href="http://www.eclipse.org/resources/" target="_self">Resources</a></li> 
                 <li><a  href="http://www.eclipse.org/projects/" target="_self">Projects</a></li> 
                 <li><a  href="http://www.eclipse.org/org/" target="_self">About Us</a></li> 
                </ul>
         </div>
         <div id="header-utils">
<!-- moved the search window here -->
                           <form action="http://wiki.eclipse.org/Special:Search" >
                  <input class="input" name="search" type="text" accesskey="f" value="" />
                    <input type='submit' onclick="this.submit();" name="go" id="searchGoButton" class="button" title="Go to a page with this exact name if one exists" value="Go" />&nbsp;
                    <input type='submit' onclick="this.submit();" name="fulltext" class="button" id="mw-searchButton" title="Search Eclipsepedia for this text"  value="Search" />
                </form>
		 </div>
      </div>


<!-- Eclipse Additions for the Header stop here -->
<!-- Additions and mods for leftside nav Start here -->

<!--Started nav  rip here-->
<!-- these are the nav controls main page, changes etc -->
    <div id="novaContent" class="faux">
            <div id="leftcol">
          <ul id="leftnav">
<!-- these are the page controls, edit history etc -->
            	  <li class="separator"><a class="separator">Navigation &#160;&#160;</li>
                                <li id="n-mainpage"><a href="http://wiki.eclipse.org/Main_Page">Main Page</a></li>
	                                <li id="n-portal"><a href="http://wiki.eclipse.org/Eclipsepedia:Community_Portal">Community portal</a></li>
	                                <li id="n-currentevents"><a href="http://wiki.eclipse.org/Eclipsepedia:Current_events">Current events</a></li>
	                                <li id="n-recentchanges"><a href="http://wiki.eclipse.org/Special:Recentchanges">Recent changes</a></li>
	                                <li id="n-randompage"><a href="http://wiki.eclipse.org/Special:Random">Random page</a></li>
	                                <li id="n-help"><a href="http://wiki.eclipse.org/Help:Contents">Help</a></li>
		  <li class="separator"><a class="separator">Toolbox &#160;&#160;</a></li>

				<li id="t-whatlinkshere"><a href="http://wiki.eclipse.org/Special:Whatlinkshere/SMILA/BPEL_Designer">What links here</a></li>
				<li id="t-recentchangeslinked"><a href="http://wiki.eclipse.org/Special:Recentchangeslinked/SMILA/BPEL_Designer">Related changes</a></li>
                <!-- This is the toolbox section -->
<li id="t-upload"><a href="http://wiki.eclipse.org/Special:Upload">Upload file</a></li>
<li id="t-specialpages"><a href="http://wiki.eclipse.org/Special:Specialpages">Special pages</a></li>
				<li id="t-print"><a href="http://wiki.eclipse.org/index.php?title=SMILA/BPEL_Designer&amp;printable=yes">Printable version</a></li>				<li id="t-permalink"><a href="http://wiki.eclipse.org/index.php?title=SMILA/BPEL_Designer&amp;oldid=293873">Permanent link</a></li>	  </ul>
        </div>


<!-- Additions and mods for leftside nav End here -->


  <div id="column-content">
    <div id="content">
      <a name="top" id="top"></a>

              <div id="tabs">
         <ul class="primary">
                                         <li class="active"><a href="BPEL_Designer.html"><span class="tab">Page</span></a></li>
                                                         <li><a href="http://wiki.eclipse.org/index.php?title=Talk:SMILA/BPEL_Designer&amp;action=edit"><span class="tab">Discussion</span></a></li>
                                         <li><a href="http://wiki.eclipse.org/index.php?title=SMILA/BPEL_Designer&amp;action=edit"><span class="tab">View source</span></a></li>
                                         <li><a href="http://wiki.eclipse.org/index.php?title=SMILA/BPEL_Designer&amp;action=history"><span class="tab">History</span></a></li>
                                         <li><a href="http://wiki.eclipse.org/index.php?title=Special:Userlogin&amp;returnto=SMILA/BPEL&#32;Designer"><span class="tab">Edit</span></a></li>
                  </ul>
        </div>


          <script type="text/javascript"> if (window.isMSIE55) fixalpha(); </script>
            <h1 class="firstHeading">SMILA/BPEL Designer</h1>
      <div id="bodyContent">
        <h3 id="siteSub">From Eclipsepedia</h3>
        <div id="contentSub"><span class="subpages">&lt; <a href="../SMILA.html" title="SMILA">SMILA</a></span></div>
                              <div id="jump-to-nav">Jump to: <a href="BPEL_Designer.html#column-one">navigation</a>, <a href="BPEL_Designer.html#searchInput">search</a></div>          <!-- start content -->
          <p>This page describes how to edit SMILA pipelines in the BPEL Designer.
</p>
<table id="toc" class="toc" summary="Contents"><tr><td><div id="toctitle"><h2>Contents</h2></div>
<ul>
<li class="toclevel-1"><a href="BPEL_Designer.html#Introduction"><span class="tocnumber">1</span> <span class="toctext">Introduction</span></a></li>
<li class="toclevel-1"><a href="BPEL_Designer.html#Installation"><span class="tocnumber">2</span> <span class="toctext">Installation</span></a>
<ul>
<li class="toclevel-2"><a href="BPEL_Designer.html#BPEL_Designer"><span class="tocnumber">2.1</span> <span class="toctext">BPEL Designer</span></a></li>
<li class="toclevel-2"><a href="BPEL_Designer.html#SMILA_designer_plugins"><span class="tocnumber">2.2</span> <span class="toctext">SMILA designer plugins</span></a></li>
</ul>
</li>
<li class="toclevel-1"><a href="BPEL_Designer.html#Development"><span class="tocnumber">3</span> <span class="toctext">Development</span></a></li>
<li class="toclevel-1"><a href="BPEL_Designer.html#RAP_showcase"><span class="tocnumber">4</span> <span class="toctext">RAP showcase</span></a>
<ul>
<li class="toclevel-2"><a href="BPEL_Designer.html#Limitations"><span class="tocnumber">4.1</span> <span class="toctext">Limitations</span></a></li>
<li class="toclevel-2"><a href="BPEL_Designer.html#How_to_set_up_the_example"><span class="tocnumber">4.2</span> <span class="toctext">How to set up the example</span></a></li>
</ul>
</li>
</ul>
</td></tr></table><script type="text/javascript"> if (window.showTocToggle) { var tocShowText = "show"; var tocHideText = "hide"; showTocToggle(); } </script>
<a name="Introduction"></a><h2> <span class="mw-headline"> Introduction </span></h2>
<p>The <a href="http://www.eclipse.org/bpel/" class="external text" title="http://www.eclipse.org/bpel/" rel="nofollow">BPEL Designer</a> is an eclipse project that offers support for editing WS-BPEL 2.0 processes. Like other eclipse projects it may be extended using plugins. The SMILA project offers such plugins for editing SMILA specific activities (to invoke SMILA "pipelets" from a pipeline).
</p>
<a name="Installation"></a><h2> <span class="mw-headline"> Installation </span></h2>
<a name="BPEL_Designer"></a><h3> <span class="mw-headline"> BPEL Designer </span></h3>
<p>How to install the BPEL Designer:
</p>
<ol><li>Download the Eclipse <i>Platform Runtime Binary</i> (at least version 3.6.2) from <a href="http://download.eclipse.org/eclipse/downloads/" class="external text" title="http://download.eclipse.org/eclipse/downloads/" rel="nofollow">here</a>.
</li><li>Unzip the package&nbsp;into an directory of your choice.
</li><li>Start eclipse.exe
</li><li>Create a workspace.
</li><li>Open the eclipse menu: Help -&gt; Install New Software...
</li><li>Enter the update site of the BPEL Designer: <a href="http://download.eclipse.org/bpel/update-site/" class="external free" title="http://download.eclipse.org/bpel/update-site/" rel="nofollow">http://download.eclipse.org/bpel/update-site/</a>
</li><li>Select the package and click [Finish]
</li></ol>
<a name="SMILA_designer_plugins"></a><h3> <span class="mw-headline"> SMILA designer plugins </span></h3>
<p>You can either build the latest version of our plugins from repository (see below) or just use our update site: <a href="http://download.eclipse.org/rt/smila/tooling/update-site/" class="external free" title="http://download.eclipse.org/rt/smila/tooling/update-site/" rel="nofollow">http://download.eclipse.org/rt/smila/tooling/update-site/</a><br />
The installation is the same as for the BPEL Designer above.
</p><p>Now you can edit SMILA pipelines with the BPEL Designer. If you'd like to start with some example BPEL files, you could use the ones from the <a href="http://dev.eclipse.org/svnroot/rt/org.eclipse.smila/trunk/core/SMILA.application/configuration/org.eclipse.smila.processing.bpel/pipelines/" class="external text" title="http://dev.eclipse.org/svnroot/rt/org.eclipse.smila/trunk/core/SMILA.application/configuration/org.eclipse.smila.processing.bpel/pipelines/" rel="nofollow">SMILA application configuration</a>
</p>
<a name="Development"></a><h2> <span class="mw-headline"> Development </span></h2>
<p>If you'd like to modify the SMILA designer plugins or compile the latest version from repository, do the following:
</p>
<ol><li> Setup your RCP IDE (you could use <a href="http://www.eclipse.org/downloads/packages/eclipse-rcp-and-rap-developers/indigosr1" class="external text" title="http://www.eclipse.org/downloads/packages/eclipse-rcp-and-rap-developers/indigosr1" rel="nofollow">this package</a>)
</li><li> Install the BPEL Designer as described above into its own directory (without the SMILA plugins)
</li><li> Select this installation as the target platform (Window-&gt;Preferences-&gt;Plug-in Development-&gt;Target Platform)
</li><li> Checkout the SMILA designer plugins (<a href="https://dev.eclipse.org/svnroot/rt/org.eclipse.smila/trunk/tooling" class="external free" title="https://dev.eclipse.org/svnroot/rt/org.eclipse.smila/trunk/tooling" rel="nofollow">https://dev.eclipse.org/svnroot/rt/org.eclipse.smila/trunk/tooling</a>)
</li></ol>
<p>Don't forget to inform us if you have a really cool modification that you would like to share&nbsp;;-)
</p>
<a name="RAP_showcase"></a><h2> <span class="mw-headline"> RAP showcase </span></h2>
<p>The <a href="http://www.eclipse.org/rap/" class="external text" title="http://www.eclipse.org/rap/" rel="nofollow">Rich Ajax Platform</a> is an Eclipse project that enables RCP applications to run in a web browser. During the implementation of our BPEL Designer extensions we tried to run the BPEL Designer as RAP application.
</p><p>Here is a screenshot:
</p><p><a href="http://wiki.eclipse.org/Image:BPEL_RAP_Screenshot.png" class="image" title="BPEL Designer in RAP screenshot"><img alt="BPEL Designer in RAP screenshot" src="http://wiki.eclipse.org/images/thumb/f/fd/BPEL_RAP_Screenshot.png/640px-BPEL_RAP_Screenshot.png" width="640" height="480" border="0" /></a>
</p>
<a name="Limitations"></a><h3> <span class="mw-headline"> Limitations </span></h3>
<p>This was just a proof of concept - so many things aren't working up to now (or at least not as expected):
</p>
<ul><li> Localization - As Eclipse is using static resources, you can only enable one language per server.
</li><li> Source view - The StyledText widget is not available in RAP, that's why we had to turn off the source view for the BPEL Editor.
</li><li> Menu bar - We had to create our own "application" and left the menu bar empty by now.
</li><li> Users - To date there is no user authentication or partition whatsoever - every user shares the same workspace.
</li><li> Problems view - The 'Problems' view is always empty in RAP (may be fixed later).
</li></ul>
<a name="How_to_set_up_the_example"></a><h3> <span class="mw-headline"> How to set up the example </span></h3>
<ol><li> Create a new Eclipse installation including the RAP tools (you could use <a href="http://www.eclipse.org/downloads/packages/eclipse-rcp-and-rap-developers/indigor" class="external text" title="http://www.eclipse.org/downloads/packages/eclipse-rcp-and-rap-developers/indigor" rel="nofollow">this package</a>).
</li><li> Create the RAP Runtime directory:
<ul><li> For Eclipse 3.7/RAP 1.4.0, we prepared already a working <a href="http://ubuntuone.com/0HHHLWUP6MXVDSoPhnAUx4" class="external text" title="http://ubuntuone.com/0HHHLWUP6MXVDSoPhnAUx4" rel="nofollow">RAP Runtime</a>. Just expand it into a directory (called RAP_RUNTIME from now on).
</li><li> To create the RAP Runtime by yourself follow these steps:
</li></ul>
<ol><li> Download the <a href="http://www.eclipse.org/rap/downloads/" class="external text" title="http://www.eclipse.org/rap/downloads/" rel="nofollow">bare RAP runtime</a> and expand it into RAP_RUNTIME.
</li><li> From the Eclipse Platform add the following packages to RAP_RUNTIME/eclipse/plugins:
<ul><li> com.ibm.icu*.jar
</li><li> org.eclipse.compare.core*.jar
</li><li> org.eclipse.core.filebuffers*.jar
</li><li> org.eclipse.core.filesystem*.jar
</li><li> org.eclipse.core.resources*.jar
</li><li> org.eclipse.core.variables*.jar
</li><li> org.eclipse.osgi.util*.jar
</li><li> org.eclipse.jface.text*.jar
</li><li> org.eclipse.text*.jar
</li><li> org.eclipse.ui.console*.jar
</li><li> org.eclipse.ui.editors*.jar
</li><li> org.eclipse.ui.workbench.texteditor*.jar
</li><li> org.eclipse.ltk.core.refactoring*.jar
</li></ul>
</li><li> From EMF:
<ul><li> org.eclipse.emf.common*.jar
</li><li> org.eclipse.emf.ecore*.jar
</li><li> org.eclipse.emf.edit*.jar
</li><li> org.eclipse.xsd*.jar
</li></ul>
</li><li> From WTP:
<ul><li> javax.wsdl_*.jar
</li><li> javax.xml_*.jar
</li><li> org.apache.xerces_*.jar
</li><li> org.apache.xml*.jar
</li><li> org.eclipse.jem.util*.jar
</li><li> org.eclipse.wst*.jar
</li></ul>
</li><li> Remove RAP_RUNTIME/eclipse/plugins/com.ibm.icu.base*.jar (it conflicts with the added com.ibm.icu package).
</li><li> Add empty dummy bundles for:
<ul><li> org.eclipse.equinox.p2.engine
</li><li> org.eclipse.equinox.p2.metadata
</li></ul>
</li><li> Add dummy packages that reexport the RAP packages (you can use the bundles in the prepared RAP Runtime from above as template):
<ul><li> org.eclipse.jface - reexport org.eclipse.rap.jface
</li><li> org.eclipse.swt - reexport org.eclipse.rap.rwt
</li><li> org.eclipse.ui.forms - reexport org.eclipse.rap.ui.forms
</li><li> org.eclipse.ui.navigator - reexport org.eclipse.rap.ui.navigator
</li><li> org.eclipse.ui.views - reexport org.eclipse.rap.ui.views
</li><li> org.eclipse.ui.workbench - reexport org.eclipse.rap.ui.workbench
</li><li> org.eclipse.ui - reexport org.eclipse.rap.ui
</li></ul>
</li></ol>
</li><li> Now open "Window/Preferences/Plug-in Development/Target Platform" in your Eclipse IDE and add a new empty target platform with RAP_RUNTIME as location.
</li><li> Select that target platform.
</li><li> In the preferences go to "Plug-in Development/API Baselines" and set "Missing API baseline" to "Ignore".
</li><li> Now you can patch all bundles that you need to modify for a working BPEL Designer on RAP:
<ul><li> We already created a set of <a href="http://ubuntuone.com/3EropeAdm943L2byBxho4e" class="external text" title="http://ubuntuone.com/3EropeAdm943L2byBxho4e" rel="nofollow">patched projects</a>. Just expand and import that set into your workspace.
</li><li> If you would like to create the patches yourself, follow these steps for every plugin:
<ul><li> Remove all not really required plugins.
</li><li> Check all (used) classes for missing imports.
</li><li> Remove the usage of Clipboard, ScrollBar, PrintSupport, PaintListener, MouseTrackListener and MouseMoveListener. 
</li><li> Remove static references to instantiated images and image registries, as these are created per session in RAP.
</li><li> Check the result of Display.getDefault() for 'null', as it is only available from the user-interface thread during browser requests (not during initialisation).
</li><li> Access the preferences store from the user-interface thread during browser requests only .
</li><li> Instead of IDialogConstants.*_LABEL (static variable) use IDialogConstants.get().*_LABEL.
</li><li> Remove ContentAssist from text fields (it doesn't support most of the used features up to now).
</li><li> Remove references to StyledText (missing widget in RAP).
</li></ul>
</li></ul>
</li><li> If you have any errors in your projects about missing definitions of referenced elements in "exsd" files - just ignore them (we didn't include the sources of the plugins in our Target Platform, which contain imported exsd files - you can add them manually if you like).
</li><li> Additionally you need an application configuration - in the patched projects above there is already one defined: org.eclipse.bpel.rap.
</li><li> Now go to "Run/Run Configurations", select "RAP Application", and create a new launch for this application:
<ul><li> Servlet name: bpel
</li><li> Entry point of application: designer
</li><li> On the "Bundles" tab select all bundles from your workspace, then "Add required bundles".
</li></ul>
</li><li> Now, when running the launch, your browser will open and you should see the RAP workbench (sometimes you need to hit refresh in the browser first, because the browser is open before the application has started).
</li></ol>
<p>You can create a project by right clicking in the explorer and selecting "New/Project.../General Project" (the BPEL project is not working due to missing plugins).
</p><p>The best way to add files to your project is adding them to the workspace of the launch in the file system and then refreshing the project in the project explorer.
</p><p>To open files, you need to select "Open" in the context menu of the file, double clicking does not work up to now.
</p>
<!-- 
NewPP limit report
Preprocessor node count: 10/1000000
Post-expand include size: 0/2097152 bytes
Template argument size: 0/2097152 bytes
#ifexist count: 0/100
-->

<!-- Saved in parser cache with key wikidb:pcache:idhash:28933-0!1!0!!en!2!edit=0 and timestamp 20120710093511 -->
<div class="printfooter">
Retrieved from "<a href="BPEL_Designer.html">http://wiki.eclipse.org/SMILA/BPEL_Designer</a>"</div>
          <div id="catlinks"><p class='catlinks'><a href="http://wiki.eclipse.org/Special:Categories" title="Special:Categories">Category</a>: <span dir='ltr'><a href="http://wiki.eclipse.org/Category:SMILA" title="Category:SMILA">SMILA</a></span></p></div>          <!-- end content -->
          <div class="visualClear"></div>
        </div>
      </div>


    </div>


	<!-- Yoink of toolbox for phoenix moved up -->


  </div>
  </div>
              <div id="clearFooter"/>
            <div id="footer" >  
	      <ul id="footernav">
                <li class="first"><a href="http://www.eclipse.org/">Home</a></li>
               	<li><a href="http://www.eclipse.org/legal/privacy.php">Privacy Policy</a></li>
	        <li><a href="http://www.eclipse.org/legal/termsofuse.php">Terms of Use</a></li>
		<li><a href="http://www.eclipse.org/legal/copyright.php">Copyright Agent</a></li>
                <li><a href="http://www.eclipse.org/org/foundation/contact.php">Contact</a></li>
               	<li><a href="http://wiki.eclipse.org/Eclipsepedia:About" title="Eclipsepedia:About">About Eclipsepedia</a></li>
	      </ul>
              <span id="copyright">Copyright &copy; 2012 The Eclipse Foundation. All Rights Reserved</span>
	      <p id="footercredit">This page was last modified 08:09, 15 March 2012 by <a href="http://wiki.eclipse.org/index.php?title=User:Juergen.schumacher.attensity.com&amp;action=edit" class="new" title="User:Juergen.schumacher.attensity.com">Juergen Schumacher</a>. Based on work by <a href="http://wiki.eclipse.org/index.php?title=User:Nadine.auslaender.attensity.com&amp;action=edit" class="new" title="User:Nadine.auslaender.attensity.com"> </a>, <a href="http://wiki.eclipse.org/User:Igor.novakovic.attensity.com" title="User:Igor.novakovic.attensity.com">Igor Novakovic</a> and <a href="http://wiki.eclipse.org/User:Eclipse.liefke.biz" title="User:Eclipse.liefke.biz">Tobias Liefke</a> and <a href="http://wiki.eclipse.org/index.php?title=SMILA/BPEL_Designer&amp;action=credits" title="SMILA/BPEL Designer">others</a>.</p>
	      <p id="footerviews">This page has been accessed 3,697 times.</p>
	    </div>

            <script type="text/javascript">
              var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
              document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
            </script>
            <script type="text/javascript">
              var pageTracker = _gat._getTracker("UA-910670-4");
              pageTracker._trackPageview();
            </script>
 
 	



		

<!-- 			<div class="visualClear"></div> -->
	
		<script type="text/javascript">if (window.runOnloadHook) runOnloadHook();</script>
</div>

<!-- Served in 0.051 secs. --></body></html>
