










<!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 -->
<meta http-equiv="content-type" content="text/html;charset=ISO-8859-1">
<head>
<meta http-equiv="content-type" content="text/html;charset=ISO-8859-1">

  <title>Eclipse Web Tools Platform Project Wiki: Xinjie Zhang 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">Xinjie Zhang 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>

A SVG Widget Framework Plugin will be contributed as a part of the Web Tools Project. 
It aims to help developers create Rich Web Clients, or so called Rich Internet Application, 
based on <A CLASS="external" HREF="http://www.w3.org/Graphics/SVG/">SVG</A><img class="outlink" 
src="images/out.png" alt="" /> (Scalable Vector Graphics), an open standard under development 
by <A CLASS="external" HREF="http://www.w3.org/">W3C</A><img class="outlink" src="images/out.png" alt="" />. 
An original version has been available on 
<A CLASS="external" HREF="http://www.openvue.net/projects.php">OpenVue.net</A><img class="outlink" src="images/out.png" alt="" />. This document demonstrates its main features and possible extensions.
<P>

      
      
<H3>Description of the Contribution</H3>

<P>
Rapid web application development is the goal of this plugin. A set of features are provided to serve this purpose. Let's look at the Figure 1. It is an overview of this plugin.
<P>
Figure 1: Overview<BR />
        <IMG CLASS="inline" SRC="overviewd338.gif" ALT="Figure 1: " width="909" height="684" /> 
      <P>
Its main interface is composed of five parts:
<UL>
<LI> A SVG Editor to present a SVG file with two views, namely Source and Design. Necessary Javascript code is generated to synchronize these two views(refer to Figure 2)
</LI>
<LI> An Outline View, which gives an overview of SVG widget objects with a tree;
</LI>
<LI> A Properties View, which displays the properties of selected widget(s) and allows to edit them
</LI>
<LI> An Outlook style Side-bar, where predefined SVG widgets are hosted in different categories according to their Looks & Feels
</LI>
<LI> A Preview toolbar button, click and a stand-alone SVG Player will pop up (view Figure 3). It is based on <A CLASS="external" HREF="http://xml.apache.org/batik/">Batik SVG Toolkit</A><img class="outlink" src="images/out.png" alt="" />, which provides a sophisticated SVG Swing component. However, it has been adapted into a SWT component for better integrating with Eclipse IDE.
</LI>
</UL>
<P>
Figure 2: Autogenerated Javascript Code<BR />
        <IMG CLASS="inline" SRC="jscode7f86.gif" ALT="Figure 2: " width="579" height="458" /> 
      <P>
Figure 3: Preview Window<BR />
        <IMG CLASS="inline" SRC="preview46ea.gif" ALT="Figure 3: " width="621" height="639" /> 
      <P>
This plugin also provides a simple Project Wizard to help you create an empty or a demo SVG project. There are two steps:
<UL>
<LI> Step 1. Choose a template of SVG project (refer to Figure 4). In the first version, there are only two templates : Default/Empty Project and Example Project.
</LI>
</UL>
<P>
Figure 4: New SVG Project<BR />
        <IMG CLASS="inline" SRC="new284e.gif" ALT="Figure 4: " width="500" height="500" /> 
      <P>
<UL>
<LI>  Step 2. Assign a project name (Figure 5)
</LI>
</UL>
<P>
Figure 5: Project Name<BR />
        <IMG CLASS="inline" SRC="projectname6a04.gif" ALT="Figure 5: " width="500" height="500" /> 
      <P>




<H3>Extensions</H3>
<P>
Although it has won a prize in the &quot;<A CLASS="external" HREF="http://www.scs.carleton.ca/~deugo/ice/">International Challenge for Eclipse</A><img class="outlink" src="images/out.png" alt="" />&quot;, this plugin is still far from mature. The Web Tools Project gives it a chance to become a really useful Tool, not just a Toy. There are several extensions could be predicted:
<P>
<UL>
<LI> A better Source view by integrating with other contributions, e.g. X-Men, <A CLASS="wikipage" HREF="Wikica4a.html">see Jens Lukowski proposal</A>;
</LI>
<LI> A feature-rich Javascript Editor and Debugger, it may be also available from other contributions;
</LI>
<LI> A light weight SVG Player. It will be provided as a Java Applet with limited features. The point is, it should be compatible with Microsoft JVM 1.1.4 and the size is expected to be limited in 500kb. In this way, a SVG web application could be deployed in most computers;
</LI>
<LI> Integrate with Java Application Server technologies;
</LI>
<LI> Be able to import Flash components and pack a SVG application into a single compressed file;
</LI>
<LI> More SVG widgets with different Looks & Feels , some powerful data and chart widgets etc
</LI>
</UL>
<P>
<H3>Conclusion</H3>
<P>
The SVG has a lot of potential to be a perfect language for Rich Internet Application. This plugin aims to turn its potential into reality. Moreover, its integration with other Java Application Server plugins extends its value.
      <P>&nbsp; 
    </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>