<?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 		= "Eclipse Webinars";
	$pageKeywords	= "";
	$pageAuthor		= "Ian Skerrett";
	
	# 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("My Page Links", 	"downloads.php");
	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 1);
	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 1);

	# End: page-specific settings
	#
	// This file is linked to from lots of different places.
	// Use absolute paths to make sure that we can actually test
	// that the file renders properly (i.e. testing using) "/index.php",
	// and "/home/index.php" both work.

	# Paste your HTML content between the EOHTML markers!	
	$html = <<<EOHTML
<div id="maincontent">
	<div id="midcolumn">
		<h1>$pageTitle</h1>

		<p>Looking to learn more about the different projects involved in Callisto?  We are running a series of free
		 webinars to help you better understand how you can use the different Eclipse projects.  Take a look below 
		 and sign-up today.</p>
		 <p><i>Special thanks to Adobe for contributing access to their <a href="http://www.adobe.com/products/breeze/?sdid=HCSA">Macromedia 
		 Breeze</a> meeting service to host these webinars.</i></p>

		<h2>Using the Eclipse Modeling Frameworks</h2>
		 <a href="http://adobedev.breezecentral.com/p17835008/">Webinar Recording</a>
		<p>
		<ul>
			<li><p> Presenters: Ed Merks and Richard Gronback, Eclipse Modeling Project Co-leaders </p></li>
			<li><p>There is great potential with model-driven development techniques to reduce the complexity and 
			effort required to develop high quality applications, while promoting a focus on domain models. The new 
			Eclipse Modeling Project aims to unify and promote such technologies within the Eclipse community, with 
			two important projects presented here to illustrate the potential of the approach. </p>
 
			<p>The Eclipse Modeling Framework (EMF) is a modeling framework and code generation facility for 
			building tools and other applications based on a structured data model. From a model specification 
			described in one of several supported formats, EMF provides tools and runtime support to produce a set 
			of Java classes for the model, a set of adapter classes that enable viewing and command-based editing of 
			the model, and a basic editor. </p>
 
			<p>The Graphical Modeling Framework (GMF) provides a generative component and runtime infrastructure for 
			developing graphical editors based on EMF and the Graphical Editing Framework (GEF). GMF is therefore 
			complementary to EMF, and also leverages several of the EMF Technology (EMFT) projects, such as OCL, 
			Query, Validation, and Transaction. </p>
 
			<p>In this webinar, a domain model will be developed using EMF, resulting in a generated set of model 
			and edit code.  A graphical editor for this domain model will also be defined and generated using GMF 
			to illustrate how model-driven development techniques are currently being used within the context of 
			the Eclipse Modeling Project. </p>
		</ul>	
		</p>
					
		<h2>Building Data Centric RCP Applications</h2>
		 <a href="http://adobedev.breezecentral.com/p89156273/">Webinar Recording</a>
		<p>
			<ul>
			<li><p> Presenters: John Graham, DTP PMC Leader,<br> Linda Chan, DTP PMC and BIRT Committer, <br> Jason Weathersby, BIRT PMC </p></li>
			<li><p> Learn how to use the new Data Tools Platform (DTP) and Business Intelligence and Report Tools (BIRT) to create 
			stand alone desktop applications that run on Eclipse RCP. The webinar will describe how to use the DTP data access capability to connect
			to multiple data stores and then create dynamic reports using BIRT.</p></li>
			<li>A recording of this webinar can be viewed <a href=" http://adobedev.breezecentral.com/p89156273/">here.</a>  
			The sample code used during the webinar is located <a href="http://www.eclipse.org/downloads/download.php?file=/datatools/downloads/callisto/webinar_060506/webinar_demo.zip">here.</a></ul>	
		</p>
	
		<h2>Developing and Profiling Web Services</h2>
		 <a href="http://adobedev.breezecentral.com/p83921118/">Webinar Recording</a>

		<p>
		<ul>
			<li><p> Presenters: Kathy Chan, WTP and Valentian Popsescu, TPTP</p></li>
			<li><p> The Web services tool in WTP allows the user to develop and consume Web services.  It also lets 
			the user easily monitor the SOAP traffic, test the Web services using the Web Services Explorer or 
			using the generated sample JSPs.   Come to this webinar to learn to use the newly updated Web services 
			tools in WTP 1.5. </p>

			<p>The TPTP tools can be used to analyze the Web application execution and look for performance hot 
			spots or memory leaks.   </p>

			<p>In this webinar, the Web services tools will be used to develop a Web service from a WSDL file and to 
			test the Web service using the Web Services Explorer.  The Web services tools will then be used to 
			generate a Web service client proxy to talk to the Web service and invoke it using the generated sample 
			JSP while monitoring the SOAP traffic using the TCP/IP monitor.  Afterwards, the TPTP tool will be used 
			to start profiling the Web application and to set the profiling filters and options.  Then, various 
			TPTP views will be used to analyze the application execution and look for performance hot spots. 
			</p> </li>
			<li>A recording of this webinar can be viewed <a href="http://adobedev.breezecentral.com/p83921118/">here</a></ul>	
		</ul>	
		</p>



	</div>
</div>

	
EOHTML;


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