<!-- 
	This document is provided as a template along with some guidance for creating
	your project proposal. This is just a template. Feel free to change it as
	you see fit (add sections, remove section). We feel, however, that the
	suggestions represented in this document represent the reasonable minimum
	amount of information to move forward.
	
	Please keep the formatting in this document simple. Please do not edit 
	this document in Microsoft Word as it adds huge piles of markup that make
	it difficult to restyle.
	
	More information is available here:
	
	http://wiki.eclipse.org/Development_Resources/HOWTO/Pre-Proposal_Phase
	
	Direct any questions about this template to emo@eclipse.org
 -->

<html>
<head>

<!-- 
	Include the title here. We will parse it out of here and include it on the
	rendered webpage. Do not duplicate the title within the text of your page.
 -->

<title>Vex</title>
</head>

<!-- 
	We make use of the 'classic' HTML Definition List (dl) tag to specify
	committers. I know... you haven't seen this tag in a long while...
 -->
 
<style>
dt {
display: list-item;
list-style-position:outside;
list-style-image:url(/eclipse.org-common/themes/Phoenix/images/arrow.gif);
margin-left:16px;
}
dd {
margin-left:25px;
margin-bottom:5px;
}
</style>

<body>
<p>The Vex project is a proposed open source project under the <a
	href="http://www.eclipse.org/mylyn/" target="_top">Mylyn
- Documentation</a> container project.</p>
<!-- 
	The communication channel must be specified. Typically, this is a forum
	that is available from http://www.eclipse.org/forums with a URL using the
	project's short name; it will be something along the lines of
	of http://www.eclipse.org/forums/eclipse.woolsey. EMO can (and will)
	provide assistance if you're not sure what to put here.
 -->
<p>This proposal is in the Project Proposal Phase (as defined in the
Eclipse Development Process) and is written to declare its intent and
scope. We solicit additional participation and input from the Eclipse
community. Please send all feedback to the <a href="http://www.eclipse.org/forums/eclipse.vex">Vex Forum.</a></p>
<h2>Background</h2>

<p>XML is being used more and more in document file formats. Such
formats as DocBook, and DITA have been used to help provide a common
format for document meta data. It helps separate the content from the
presentation. As word processor formats move to XML like OpenOfficeXML
and OpenDocument, it becomes more critical to have a WYSIWYG interface
for these file formats. Most users that have to write books, articles,
and other print related material don't want to deal with the tags for
the files, but they want the convenience and separation of presentation
that these formats provide.</p>

<!-- 
	Optionally provide the background that has lead you to creating this project.
 -->

<h2>Scope</h2>

<p>The Visual XML Editor is a set of plugins that provide WYSIWYG
editing ability for XML files. This can be used regardless of the XML
involved, and uses CSS stylesheets to provide the formatting for the
presentation layer. All that is needed is an stylesheet and an
appropriate XML file to edit. It hides the XML tags from the user, allow
them to have a word processor like experience but store the information
in the native XML format.</p>
<!-- 
	All projects must have a well-defined scope. Describe, concisely, what
	is in-scope and (optionally) what is out-of-scope. An Eclipse project
	cannot have an open-ended scope.
 -->

<h2>Description</h2>

<!-- 
	Describe the project here. Be concise, but provide enough information that
	somebody who doesn't already know very much about your project idea or domain
	has at least a fighting chance of understanding its purpose.
 -->
 
 <p>Vex will be based off of a contribution from the Vex (Visual
Editor for XML) project, originally created by John Krasnay and hosted
at sourceforge.net. This code was donated to eclipse and has been an
Eclipse Web Tools Incubator component. The goal of the project is to
provide a WYSIWYG XML Editor primarily targeted for those using XML
authoring file formats. It will be leverage existing XML support and
frameworks from the Web Developers Tools project. Particularly, the
Structure Source Editor, as well as the WTP validation frameworks. It
will also make use of the DTD and XML schema support for the files as
well. It provides a plugin architecture that allows for the use with any
arbitrary XML file, and creation of new CSS style sheets that can be
used with existing known document formats.</p>
 
<h2>Initial Contribution</h2>

<!-- 
	Describe any existing code that will be contributed to the project.
 -->
<p>All code is currently incubating with in the Web Tools Incubator
project. The current committers are shooting for a spring graduation
date. The code has consistent Hudson builds, and is using git as the
sour code control system. Builds are using Maven 3 and Tycho. P2 update
sites are available. The code supports DITA and DocBook formats out of
the box.</p>
 
<h2>Legal Issues</h2>

<!-- 
	Please describe any potential legal issues in this section. Does somebody else
	own the trademark to the project name? Is there some issue that prevents you
	from licensing the project under the Eclipse Public License? Are parts of the 
	code available under some other license? Are there any LGPL/GPL bits that you
	absolutely require?
 -->
 <p>All code has been reviewed and approved through the Eclipse IP
Process. There are no outstanding CQs that need to be completed or
approved. All past contributors on the SourceForge project have approved
the relicensing of the code under the Eclipse Public License.</p>
 
<h2>Committers</h2>

<!-- 
	List any initial committers that should be provisioned along with the
	new project. Include affiliation, but do not include email addresses at
	this point.
 -->

<p>The following individuals are proposed as initial committers to the project:</p>

<dl>
	<dt>David Carver, Intalio Inc.</dt>
	<dd>David Carver, is a committer on the Web Tools Source Editing
	project, Orbit, and XQuery web tools incubator project. He is also a
	current member of the Eclipse Architecture Council.</dd>
	<dt>Holger Voorman, Agilantis</dt>
	<dd>Holger Voorman, is a commiter on the Web Tools Incubator Vex
	component.</dd>
	<dt>Florian Thienel, Thienel Software</dt>
	<dd>Florian Thienel, is a commiter on the Web Tools Incubator Vex
	component.</dd>
	<dt>Igor Jacy Lino Campista</dt>
	<dd>Igor Jacy Lino Campista, is a commiter on the Web Tools
	Incubator Vex component.</dd>
</dl>

<p>We welcome additional committers and contributions.</p>

<!-- 
	Describe any initial contributions of code that will be brought to the 
	project. If there is no existing code, just remove this section.
 -->

<h2>Mentors</h2>

<!-- 
	New Eclipse projects require a minimum of two mentors from the Architecture
	Council. You need to identify two mentors before the project is created. The
	proposal can be posted before this section is filled in (it's a little easier
	to find a mentor when the proposal itself is public).
 -->

<p>The following Architecture Council members will mentor this
project:</p>
<div class="itemizedlist">
<ul class="itemizedlist" type="disc">
	<li class="listitem">
	<p>David Carver</p>
	</li>
	<li class="listitem">
	<p>Mik Kersten</p>
	</li>
</ul>

<h2>Interested Parties</h2>

<!-- 
	Provide a list of individuals, organisations, companies, and other Eclipse
	projects that are interested in this project. This list will provide some
	insight into who your project's community will ultimately include. Where
	possible, include affiliations. Do not include email addresses.
 -->

<p>The following individuals, organisations, companies and projects have 
expressed interest in this project:</p>

<p>The following individuals, organisations, companies and projects
have expressed interest in this project:</p>
<ul class="itemizedlist" type="disc">
	<li class="listitem">
	<p>Standards for Technology in Automotive Retail</p>
	</li>
	<li class="listitem">
	<p>PI-Mod Project</p></li>
</ul>

<h2>Project Scheduling</h2>

<p>The tentative plan is to get the existing code migrated and
aligned with the Mylyn project's development process. This will include:</p>

<ul class="itemizedlist" type="disc">
	<li class="listitem">
	<p>Migrate Code to Mylyn and do package renaming.</p>
	</li>
	<li class="listitem">
	<p>Update and create documentation.</p>
	</li>
	<li class="listitem">
	<p>Continuing Integrating source views to leverage existing SSE
	editing and XML functionality. As well as Mylyn functionality. This is
	an on going process..</p>
	</li>
	<li class="listitem">
	<p>Continue working on support for displaying Images within the
	editor.</p>
	</li>
	<li class="listitem">
	<p>Provide base line Cookbook examples for creating appropriate
	stylesheets.</p>
	</li>
	<li class="listitem">
	<p>Provide Mylyn Task editor integration and context support where
	possible.</p>
	</li>
</ul>
</body>
</html>