










<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
        "http://www.w3.org/TR/html4/loose.dtd">

<html>


<!-- Mirrored from wiki.objectweb.org/eclipse-webtools/Wiki.jsp?page=ObjectwebContributions by HTTrack Website Copier/3.x [XR&CO'2003], Fri, 23 Apr 2004 19:12:18 GMT -->
<!-- Mirrored from www.eclipse.org/proposals/eclipse-webtools/Wikib9cc.html by HTTrack Website Copier/3.x [XR&CO'2003], Tue, 25 May 2004 06:27:32 GMT --><head>
<meta http-equiv="content-type" content="text/html;charset=ISO-8859-1">

<meta http-equiv="content-type" content="text/html;charset=ISO-8859-1">

  <title>Eclipse Web Tools Platform Project Wiki: Jens Lukowski Contributions</title>
  <link rel="stylesheet" href="templates/eclipse/eclipse.css">
  
<meta http-equiv="content-type" content="text/html;charset=ISO-8859-1">
  
</head>

<body>

<table border="0" cellspacing="5" cellpadding="2" width="100%" >
  <tr>
    <td align="left" width="60%"><font class="indextop">eclipse web tools<br>platform project</font><br><font class="indexsub">Jens Lukowski Contributions</font></td>
    <td width="40%"><img src="images/Idea.jpg" hspace="50" align="center" width="120" height="86"></td>
  </tr>
</table>



<table border="0" cellspacing="5" cellpadding="2" width="100%" >
  <tr>
    <td valign="top">

  









<HR />
This project proposal is in the
<a href="/projects/dev_process/">
Proposal Phase</a> and is posted here to solicit additional project 
participation and ways the project can be leveraged from the Eclipse 
membership-at-large. You are invited to comment on and/or
<a href="Wikiaed0.html">join the project</a>. Please send all feedback to the
<a href="http://www.eclipse.org/newsportal/thread.php?group=eclipse.webtools">eclipse.webtools</a> 
newsgroup or the <a href="https://dev.eclipse.org/mailman/listinfo/wtp-proposal">
wtp-proposal</a> mailing list.
<HR />

<H3>Introduction</H3>


The eclipse Web Tools Platform Project aims to extend the eclipse tool integration platform with plug-ins that support the development of web applications. One important standard of web development is XML. The subject of this contribution is the open source <A CLASS="external" HREF="http://www.sourceforge.net/projects/xmen">X-Men project</A><img class="outlink" src="images/out.png" alt="" />, a XML plugin for Eclipse, for the initial code base of the Eclipse Web Tools Platform Project. The X-Men code base is released under an Eclipse compatible license (CPL). 
<P>
<H3>Description of the Contribution</H3>
<P>
The X-Men project provides a set of tools that are useful to XML developers to perform their common tasks. These include: 
<UL>
<UL>
<LI>Source View 
</LI>
<LI>Table View 
</LI>
</UL>
</UL>
All views handle well formed XML as well as malformed XML. 
<P>
In the following sections I provide some detail about these contributions. 
<P>
<H3>Source View</H3>
This view supports syntax highlighting, content assist (based on DTDs and XSDs), highlighting of the corresponding tag and an instant updating outline view. 
<P>
Figure 1: Source View with corresponding tag highlighting<BR />
        <IMG CLASS="inline" SRC="source8105.jpg" ALT="Figure 1: " width="838" height="613" /> 
      <P>
<P>
<P>
<H3>Table View</H3>
Sometimes, especially with large XML documents, the source view isn't the right tool to view XML. You need a view more adapted to the hierarchical structure of XML. The table view provides such a tool. 
<P>
Figure 2: Table View<BR />
        <IMG CLASS="inline" SRC="table7a44.jpg" ALT="Figure 2: " width="832" height="613" /> 
      <P>
<H3>Summary</H3>
      <P> The X-Men contribution will complete the XML development tools and also 
        provide a point for discussion and alternative ways of achieving the goals 
        with different design decisions.
      <p class="small">&nbsp;</p>



















    </td>
  </tr>

</table>

</body>

<!-- Mirrored from wiki.objectweb.org/eclipse-webtools/Wiki.jsp?page=ObjectwebContributions by HTTrack Website Copier/3.x [XR&CO'2003], Fri, 23 Apr 2004 19:12:22 GMT -->

<!-- Mirrored from www.eclipse.org/proposals/eclipse-webtools/Wikib9cc.html by HTTrack Website Copier/3.x [XR&CO'2003], Tue, 25 May 2004 06:27:32 GMT -->
<meta http-equiv="content-type" content="text/html;charset=ISO-8859-1">
</html>