<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'

	#*****************************************************************************
	#
	# template.php
	#
	# Author: 		Denis Roy
	# Date:			2005-06-16
	#
	# Description: Type your page comments here - these are not sent to the browser
	#
	#
	#****************************************************************************
	
	#
	# Begin: page-specific settings.  Change these. 
	$pageTitle 		= "New &amp; Noteworthy Archives";
	$pageKeywords	= "BPEL Apache ODE";
	$pageAuthor		= "Bob Brodt";
	
	# Add page-specific Nav bars here
	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
	# $Nav->addNavSeparator("Interesting Links", 	"");
	# $Nav->addCustomNav("Scientific Workflows using BPEL", "http://sse.cs.ucl.ac.uk/index.php?id=omii-bpel", "_blank", 1);
	# $Nav->addCustomNav("WS-BPEL 2.0", "http://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html", "_blank", 1);
	# $Nav->addCustomNav("OASIS TC", "http://www.oasis-open.org/committees/tc_home.php?wg_abbrev=wsbpel", "_blank", 1);
	
	# End: page-specific settings
	#
		
	# Paste your HTML content between the EOHTML markers!	
	$html = <<<EOHTML

<div id="maincontent">
	<div id="midcolumn">
		<h1>$pageTitle</h1>
		<h2>(but not necessarily Old &amp; Inconsequential)</h2>
		<ul>
				<li><b>June 28, 2011 &ndash; We're moving!</b>
				We are planing on moving the BPEL Designer project from
				<a href="http://www.eclipse.org/technology">Technology project</a>
				to the
				<a href="http://www.eclipse.org/soa">SOA top-level project</a>.
				The restructuring document which outlines the details of this move can be found
				<a href="http://wiki.eclipse.org/BPEL_Restructuring">in the project wiki, here</a>.
				This web page will be updated as we get closer to the move date.
				</li>
     		
				<li><b>Mar. 10, 2011 &ndash; Updated extension activity samples.</b>
				Several of you in the community have been asking about extension activities and how to
				more fully integrate them with the editor.
				
				The updated sample code includes extended property section tabs for the simple and
				structured extension activities as well as exemplary code demonstrating how to handle
				references to the existing BPEL model.
				
				The sample plug-ins can be found here in the
				<a class="www" href="https://git.eclipse.org/c/bpel/org.eclipse.bpel.git/tree/examples/plugins">Git repository</a> 
				</li>
     		
				<li><b>Feb. 15, 2011 &ndash; Proposal for UI enhancements.</b>
				One of our committers has been busy thinking about how to improve the BPEL Designer user experience.
				Read all about it
				<a href="/$projectShortName/users/pdf/BPEL_UI_Enhancements_v1.0.pdf">here.</a>
				</li>
     		
     		
				<li><b>Feb. 14, 2011 &ndash; CVS Commit Notification Mailing List is now available.</b>
				Please visit
				<a class="www" href="https://dev.eclipse.org/mailman/listinfo/bpel-commits">the Eclipse mailing list subscription page</a>
				to sign up.
				</li>
     		
				<li><b>Sept. 17, 2010 &ndash; Good news everyone!</b>
				The
				<a class="www" href=$update_site target="download">update site</a>
				has been updated and we are now doing nightly builds.
				The previous build (0.4.0) is still <a class="www" href=$update_site-M4 target="download">available here.</a>
				</li>
     		
     		
				<li><b>Sept. 10, 2010 &ndash; Next milestone plan (M5) announced</b>
				A "code stabilization" plan is in the works. <a href="/$projectShortName/users/m5.php">Check it out here</a>.
				<a href="http://www.eclipse.org/forums/index.php?t=thread&frm_id=43">Comments and suggestions are always welcome!</a>
				</li>
     		
				<li><b>Sept. 7, 2010 &ndash; New project website is up!</b>
				If you can read this and your browser hasn't crashed yet, life is good :)
				</li>
				<li><b>Sept. 1, 2010 &ndash; M4 release is available</b>
				Check out the latest
				<a href="/$projectShortName/users/m4.php">bug fixes and enhancements.</a>
				</li>
		</ul>
	</div>
</div>

EOHTML;


	# Generate the web page
	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
?>
