<?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: 		Nathan Gervais
	# Date:			2007-12-05
	#
	# Description: DTP Website
	#
	#
	#****************************************************************************
	
	#
	# Begin: page-specific settings.  Change these. 
	$pageTitle 		= "Eclipse Data Tools Platform (DTP) Project Community";
	$pageKeywords	= "eclipse, data tools, dtp, datatools";
	$pageAuthor		= "Nathan Gervais";
	
	ob_start();
	?>
	
	<div id="midcolumn">
		<h1><?=$pageTitle; ?></h1>
		<div class="homeitem3col">
			<h3>DTP Community Page</h3>
			<p>As an eclipse.org project, a fundamental goal for DTP is to build a strong community of adopters. The intention of this page is to provide brief descriptions of DTP adopters, so those considering building on the Data Tools Platform can gauge the range and typical use that has already been achieved in the community.</p>
			<p>We welcome additions to this page from organizations and individuals, both extenders of DTP and end users. Please e-mail the <a href="mailto:dtp-pmc@eclipse.org">DTP PMC</a> for further details.
			<p><a href="http://www.actuate.com/">Actuate BusinessReport Studio</a>: BusinessReport Studio provides a comprehensive web based, self-service environment where power and business users can access the information they need, analyze it and develop reports that can be shared with other users in order to facilitate faster and more effective decisions. BusinessReport Studio utilizes the Eclipse BIRT and DTP projects for the underlying data access and formatting.</p>
			<p><a href="http://www.actuate.com\birt/">Actuate BIRT Report Designer Pro</a>: Actuate BIRT is a powerful and flexible Java reporting tool for building and deploying reports against data sources ranging from typical business SQL databases, to XML data sources, to in-memory Java objects. Actuate BIRT is based on the Eclipse Open Source BIRT project and benefits from the capabilities of the Eclipse platform and a very active community of users. Actuate BIRT leverages DTP for it's rich and extensible data access capabilities.</p>
			<p><a href="http://aws.amazon.com/eclipse/">AWS Toolkit for Eclipse</a>: The AWS Toolkit for Eclipse is an open source plug-in for the Eclipse Java IDE that makes it easier for developers to develop, debug, and deploy applications using Amazon Web Services. The plug-in uses DTP in its Amazon SimpleDB Management feature, making it easy to configure, edit, and query data in SimpleDB. Check out the <a href="http://aws.amazon.com/eclipse/">AWS Toolkit for Eclipse web site</a> for more information, including a short screencast.</p>
			<p><a href="http://www.eclipse.org/birt/phoenix/">BIRT 2.1</a> adopts the DTP Open Data Access (ODA) and Connection Profile frameworks for heterogenous data access services. Both BIRT report designer and report engine are ODA hosts that consume any ODA designers and runtime drivers.</p>
			<p><a href="http://www.eclipse.org/webtools/">Eclipse Web Tools Platform (WTP)</a>: Is adopting DTP in their 2.0 ("Europa") release. See this email on <a href="http://dev.eclipse.org/mhonarc/lists/wtp-pmc/msg00943.html">wtp-pmc</a> for details.</p>
			<p><a href="http://www.jboss.com/products/devstudio">JBoss Developer Studio</a> uses DTP for easy configuring of it's JBoss Seam support in JBDS 1.0. In JBDS 2, DTP will be used even more for easy configuration of the connection for Hibernate and it is also adding a Hibernate based datasource to be used in BIRT. The development of the individual plug-ins in JBDS is open source and available from <a href="http://www.jboss.org/tools">JBoss Tools.</a></p>
			<p><a href="https://www.jfire.org/modules/phpwiki/index.php/JFireReporting%20JFS%20Datasource">JFireReporting ODA module</a> is part of the <a href="https://www.jfire.org/modules/content/">JFire ERP system.</a> It extends the ODA datasource extension-points and integrates into the BIRT adoption of JFire. The module lets JFire users choose a JFire script that serves as datasource for statistics, offers, orders etc.. The JFire ERP system and its extensions are licensed under LGPL.</p>
			<p><a href="http://www.liquibase.org/">LiquiBase Database Refactoring Plugin for Eclipse</a> builds on the core LiquiBase database change management system to provide the same refactoring experience found in the Eclipse Java editor for database development.</p>
			<p><a href="http://www.nexaweb.com/home/us/index.html@cid=2291.html">Nexaweb EW2.0 Platform</a> is a comprehensive development and run-time framework for building, deploying, and maintaining mission-critical Web 2.0 applications. Consisting of a Universal Client Framework (UCF), Enterprise Data Services, Internet Messaging Bus and Nexaweb Studio (an Eclipse-based IDE), the platform enables declarative programming across a range of client environments (including Ajax and Java) bringing efficiency and rapid ROI throughout the Application Lifecycle. It also fully embraces established and emerging OSS technologies � in Apache, Eclipse and other leading OSS communities.</p>
			<p>
    Nexaweb Studio uses DTP to make it easy to bind visual Ajax and Java components to relational data bases for viewing, creating and updating data using the platform�s Enterprise Data Services technology. Using Studio, mapping of data base tables to UI elements (list box, combo box, table, tree, tree table) is drag-n-drop and point-n-click. Nexaweb Studio integrates various wizards � for data binding, sql statements and more � with DTP Data Source Explorer as well as Nexaweb Studio�s own Visual Editor. It also presents DTP-defined data sources along with other data sources and data service-related elements in its data perspectives.</p>
			<p><a href="http://wiki.nightlabs.de/en/EclipseGoodies:Birt_JDO">NightLabs BIRT-JDO</a> integration provides a custom datasource for ODA consumer applications. The extension allows the configuration of a JDO datastore connection and the execution of JDOQL scripts on this datastore. It shows the usage of the ODA extension-points for datasources and their UI. The BIRT-JDO projects are made available under the Eclipse Public License.</p>
			<p><a href="http://www.oracle.com/technology/products/enterprise-pack-for-eclipse/index.html">Oracle Database Plugin for Eclipse Data Tools Platform:</a> As a further commitment to the Eclipse Community, Oracle announces an early adopter release of the Oracle Database Plugin for Eclipse Data Tools Platform. This plugin extends the Eclipse Data Tools Platform to connect to and work with Oracle database objects. The initial plugin supports the ability to connect to Oracle Databases, navigate through all database objects, execute stored procedures and functions, and view textual and graphical execution plans.</p>
			<p><a href="http://www.sybase.com/workspace">Sybase WorkSpace 2.0</a> release will leverage key features in the 1.5 release of the Data Tools Platform (DTP) Project. Use of the SQL editing/debugging framework and the connectivity layer in DTP will allow Sybase customers greater support for heterogeneous server environments. This will enhance the overall ease of use and productivity of WorkSpace's Data tooling.</p> 
		</div>
	</div>

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