<!DOCTYPE html>
<html>

  <head>
	<meta charset="UTF-8">
	<title>Xtext - News</title>
	
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<meta name="description"
		content="The website of Eclipse Xtext, an open-source framework for development of programming languages and domain-specific languages">
	<meta name="author" content="Sven Efftinge">
	<meta name="author" content="Miro Spoenemann">
	<!--  styles -->
	<!-- Le HTML5 shim, for IE6-8 support of HTML5 elements -->
	<!--[if lt IE 9]>
	  <script src="http://html5shim.googlecode.com/svn/trunk/html5.js"></script>
	<![endif]-->
	
	<!-- Le fav and touch icons -->
	<link rel="shortcut icon" href="/Xtext/images/favicon.png">
	
	<link href="/Xtext/css/bootstrap.css" rel="stylesheet" type='text/css'>
	<link href="/Xtext/css/bootstrap-responsive.css" rel="stylesheet" type='text/css'>
	<link href="/Xtext/css/shield-responsive.css" rel="stylesheet" type='text/css'>
	<link href='/Xtext/css/fonts.css' rel='stylesheet' type='text/css'>
	<link href="/Xtext/css/prettyPhoto.css" rel="stylesheet" media="screen" type='text/css'>
	<link href="/Xtext/css/prettify.css" type="text/css" rel="stylesheet"/>
	<link href="/Xtext/css/style.css" rel="stylesheet" type='text/css'>
	<!-- cover flow -->
	<link href="/Xtext/css/coverflow.css" rel="stylesheet" type='text/css'>
	<!--[if lt IE 9]>
	  <link href="/css/iebugs.css" rel="stylesheet" type='text/css'>
	<![endif]-->
</head>


  <body>
  <!-- Google Tag Manager -->
<noscript><iframe src="//www.googletagmanager.com/ns.html?id=GTM-TGDS5S"
height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
<script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
'//www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
})(window,document,'script','dataLayer','GTM-TGDS5S');</script>
<!-- End Google Tag Manager -->

    <header class="site-header">

  <!-- Navbar -->
  <div class="navbar navbar-fixed-top">
    <div class="navbar-inner">
      <div class="container">
        <a class="btn btn-navbar" data-toggle="collapse"
          data-target=".nav-collapse"> <span class="icon-bar"></span> <span
          class="icon-bar"></span> <span class="icon-bar"></span>
        </a> <a class="brand" href="/Xtext/index.html"></a>
        <div class="nav-collapse collapse" style="height: 0px;">
          <ul class="nav">
            <!--li ><a href="/Xtext/news.html">News</a></li-->
            <li ><a href="/Xtext/download.html">Download</a></li>
            <li ><a href="/Xtext/documentation/index.html">Documentation</a></li>
            <li ><a href="/Xtext/community.html">Community</a></li>
            <li class="dropdown">
              <a class="dropdown-toggle" data-toggle="dropdown" href="#">Support &amp; Trainings<span class="caret"></span></a>
              <ul class="dropdown-menu">
                <li><a href="https://www.itemis.com/en/xtext/support-and-team/" target="_blank">itemis</a></li>
                <li><a href="https://typefox.io/trainings-2" target="_blank">TypeFox</a></li>
              </ul>
            </li>
            <li ><a href="http://xtend-lang.org">Xtend</a></li>
          </ul>
          <!--div class="nav pull-right">
            <li ><a><iframe src="https://ghbtns.com/github-btn.html?user=eclipse&repo=xtext&type=star&count=true" frameborder="0" scrolling="0" width="170px" height="20px"></iframe></a></li>
          </div-->
        </div>
        <!--/.nav-collapse -->
      </div>
    </div>
  </div>
  <!-- Navbar End -->

</header>


    <div id="page">  
	<div class="inner">
		<div class="container clearfix">
			<h1>Latest News</h1>
			
				<div class="post">
					<h2>Xtext 2.9 Release Candidate<small>&nbsp;&nbsp;&nbsp;Nov 11, 2015 (Sven Efftinge)</small></h2>
					<p>A release candidate of the upcoming version of Xtext can now be tried and tested. <br />
The Eclipse plugins are available through the milestone update site:</p>

<p><a href="http://download.eclipse.org/modeling/tmf/xtext/updates/composite/milestones/">http://download.eclipse.org/modeling/tmf/xtext/updates/composite/milestones/</a></p>

<p>The IntelliJ IDEA Plugins are available through this repository URL:</p>

<p><a href="http://download.eclipse.org/modeling/tmf/xtext/idea/2.9.0.rc1/updatePlugins.xml">http://download.eclipse.org/modeling/tmf/xtext/idea/2.9.0.rc1/updatePlugins.xml</a></p>

<p>You need to add that URL as a repository in IDEA and choose all three plugins (org.eclipse.xtext, org.eclipse.xtext.xtext and org.eclipse.xtend),<br />
because IDEA doesn’t pull-in dependencies automatically.</p>

<h3 id="when-is-the-release">When Is The Release?</h3>

<p>If everything goes smoothly and noone reveals major issues in this release candidate (please try hard!), <br />
we hope to get out the release on <em>December 1st</em>.</p>

<h3 id="whats-new">What’s new?</h3>

<h4 id="intellij-idea-as-an-alternative-to-eclipse">IntelliJ IDEA As An Alternative To Eclipse</h4>
<p>In addition to the existing Eclipse integration, it is now possible to design languages entirely in IntelliJ IDEA, as well.<br />
Languages developed in Eclipse can target all available platforms (Eclipse, IntelliJ IDEA (new), Web editors (new)) while when<br />
working in IDEA it is not possible to develop an Eclipse plug-in for you language. IDEA is just not so well suited for Eclipse Plug-in development.</p>

<p><em>Also note: This doesn’t mean we are dropping Eclipse support, nor are we going to think of that any time soon!</em></p>

<h4 id="headless-builds-for-xtext-projects">Headless Builds For Xtext Projects</h4>
<p>No matter what IDE you choose for development, or what target platforms for your language you want you’ll get a fully working build based on Maven and/or Gradle.<br />
So your Xtext projects can be built and published in any headless Java environment. That’s why one essentially really doesn’t need a particular<br />
tool to develop Xtext languages anymore. That said, it’s recommended to use them anyway :).</p>

<h4 id="new-project-wizard">New Project Wizard</h4>
<p>The new wizard runs in both Eclipse and IntelliJ IDEA and lets you choose, whether you want to have <br />
editor support at all (yes you can just focus on the compiler) and what build-systems you prefer.</p>

<h4 id="web-support">Web Support</h4>
<p>One of two new target platforms is web editor support for Xtext languages. With Eclipse Orion, Ace, and Code Mirror, we already support three different JS editors.<br />
Each with a slightly different set of features and requirements. Check out <a href="http://spoenemann.blogspot.de/2015/05/editing-dsls-in-web-browser.html">Miro’s blog post</a> on how to give it a spin.</p>

<h4 id="language-editors-for-intellij-idea">Language Editors for IntelliJ IDEA</h4>
<p>The other new editor target platform is IntelliJ IDEA. We even developed a <a href="https://github.com/xtext/xtext-gradle-plugin/tree/master/xtext-idea-gradle-plugin">full gradle integration</a> to build, test and run<br />
the developed IDEA plugins.</p>

<h4 id="all-new-code-generator">All New Code Generator</h4>
<p>We finally managed to rewrite the old Xtext code generator entirely in Xtend.<br />
It’s now much simpler, faster and more convenient to use and more fun to maintain :).</p>

<h4 id="new-grammar-language-features">New Grammar Language Features</h4>
<p>The Xtext Grammar Language got some new features, to reduce redundancy in more complex grammars such as an ECMAScript 6 IDE<br />
we help a customer with. <a href="http://zarnekow.blogspot.de">Sebastian has written</a> about some of them.</p>

<h4 id="many-more-fixes-and-improvements">Many More Fixes And Improvements</h4>
<p>As if that wasn’t enough new stuff, we of course have also more than 200 issues on the go.<br />
The <a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;j1=OR&amp;list_id=13155507&amp;query_format=advanced&amp;status_whiteboard=v2.9&amp;status_whiteboard_type=allwordssubstr">detailed list</a> can be found in our bug tracker.</p>


					<br/>
				</div>
			
				<div class="post">
					<h2>Xtext in IntelliJ IDEA - Preview<small>&nbsp;&nbsp;&nbsp;Oct 2, 2015 (Sven Efftinge)</small></h2>
					<p>Today we’ve released a preview version for the upcoming IntelliJ IDEA support of Xtext. <br />
With this it is now possible to <em>develop Xtext languages entirely in IDEA</em> and due to the cool Gradle support in any other environment, too.</p>

<p>The preview plugins for IntelliJ IDEA can be installed from the following repository location:</p>

<p><a href="http://download.eclipse.org/modeling/tmf/xtext/idea/2.9.0.beta5/updatePlugins.xml">http://download.eclipse.org/modeling/tmf/xtext/idea/2.9.0.beta5/updatePlugins.xml</a></p>

<p>You need to install all three plugins from this repository into the latest <a href="https://www.jetbrains.com/idea/nextversion/">IDEA 15 Preview</a>.</p>

<p>There is a <a href="https://player.vimeo.com/video/141201249">screencast on vimeo</a> that shows what Xtext in IntellijJ IDEA looks like.</p>

<p>Please try it out and provide feedback through bugzilla or elsewhere.</p>

					<br/>
				</div>
			
				<div class="post">
					<h2>Xtext 2.9 Beta<small>&nbsp;&nbsp;&nbsp;May 22, 2015 (Sven Efftinge)</small></h2>
					<p>(for download instructions, <a href="#download-links">see below</a>)</p>

<p>The main theme of our ongoing work in Xtext &amp; Xtend 2.9 is to reach out to other tools and platforms. After seven years of development, Xtext has become the de facto standard for implementing programming languages and external domain specific languages and IDE support for Eclipse. A couple of months ago, we announced that we have now started to extract the IDE-related infrastructure from Eclipse, such that it can be used in other scenarios as well.</p>

<p>Today we want to give early adopters a chance to test the current status quo and provide feedback (you always could do that, since everything we do is open-source). The “2.9 Beta” we are putting out today is a frozen state of the head, that was tested just a bit and has known issues. So it’s not an actual release and you should not use it in production! Still, it comes with some new stuff that might be interesting:</p>

<h3 id="intellij-idea-support">IntelliJ IDEA Support</h3>

<p>With 2.9 you will be able to produce a feature-rich plug-in not only for Eclipse, but also for IntellIj IDEA, from the same language description. The IntelliJ editor already supports syntax coloring and content assist and even some rename refactoring works. Also, we have been working on an incremental standalone compiler, that is used by IDEA, and automatically runs the code generators for the changed and affected files.</p>

<p>The IDEA integration hasn’t been so easy, because IDEA is already a rich platform and it’s a bit challenging to map IDEA’s concepts with ours in performant ways. So there is still some work ahead of us, especially in the case of Xbase and Xtend, where a seamless integration with the Java IDE is our goal. We are simply not there yet and especially the integration with Java is still in a very early and bad stage. If you have Xtext DSLs that don’t use Xbase, there is a lot that works quite well already.</p>

<p>Stefan has written up more infos about the IntellIJ IDEA part <a href="http://oehme.github.io/2015/05/22/xtext-intellij-beta.html">here</a>.</p>

<h3 id="weborion-support">Web/Orion Support</h3>

<p>The other part we wanted to share and get feedback on, is the early state of our web support. Same story: <b>don’t use it in production</b>! The Xtext project wizard can create a web project, which provides you with an example html webpage, an orion editor and a java-based server backend for the editor. Syntax Coloring is done entirely in the browser, while validation and content assist are provided by the server. The server side really just projects tool support on that widget and doesn’t need any other integration with your web application, just use the orion editor as a feature rich text widget.</p>

<p>The client-server communication already uses an optimized communication protocol based on text-deltas and it features a cancelation policy that will avoid any unnecessary processes. Even with large documents response time is very good.</p>

<p>Miro has written a more detailed post about this over <a href="http://spoenemann.blogspot.de/2015/05/editing-dsls-in-web-browser.html">here</a>.</p>

<p>To try it out, just download (see below) and use the new “Xtext project wizard” to create a fresh Xtext language with a dedicated project for the web support.</p>

<p><img src="/Xtext/images/news/xtext-2.9-wizard.png" alt="the new wizard" /></p>

<p>Please tell us, what you would like to do with this. Bug reports and feature requests go here : <a href="https://bugs.eclipse.org/bugs/enter_bug.cgi?product=TMF&amp;component=Xtext">bugs.eclipse.org</a></p>

<h3 id="other-themes-in-29">Other Themes In 2.9</h3>

<p>Besides the web and IDEA support, we are working on making it even simpler to build Xtext projects. One goal for instance is to allow for xtext projects without any Eclipse dependency, such that you can just use the runtime and build and deploy it with Maven or Gradle. In addition we will again spend much time on improving the overall performance and bugfixes of course.</p>

<h3 id="more-updates-soon">More updates soon</h3>

<p>The 2.9 release is planned for autumn 2015 and shall come with production ready support for IDEA and Web. Until then we will likely have more beta releases, depending on demand and progress.</p>

<h3 id="download-links">Download Links</h3>

<p>Here are the download links for the beta:</p>

<p>Ready to use eclipse distributions:</p>
<ul>
  <li><a href="http://www.eclipse.org/modeling/download.php?file=/modeling/tmf/xtext/downloads/distros/eclipse-dsl-beta5-win32-x86_64.zip&amp;r=2">eclipse-dsl-beta5-win32-x86_64.zip</a></li>
  <li><a href="http://www.eclipse.org/modeling/download.php?file=/modeling/tmf/xtext/downloads/distros/eclipse-dsl-beta5-macosx-cocoa-x86_64.tar.gz&amp;r=2">eclipse-dsl-beta5-macosx-cocoa-x86_64.tar.gz</a></li>
  <li><a href="http://www.eclipse.org/modeling/download.php?file=/modeling/tmf/xtext/downloads/distros/eclipse-dsl-beta5-linux-gtk-x86_64.tar.gz&amp;r=2">eclipse-dsl-beta5-linux-gtk-x86_64.tar.gz</a></li>
  <li><a href="http://www.eclipse.org/modeling/download.php?file=/modeling/tmf/xtext/downloads/distros/eclipse-dsl-beta5-win32.zip&amp;r=2">eclipse-dsl-beta5-win32.zip</a></li>
  <li><a href="http://www.eclipse.org/modeling/download.php?file=/modeling/tmf/xtext/downloads/distros/eclipse-dsl-beta5-linux-gtk.tar.gz&amp;r=2">eclipse-dsl-beta5-linux-gtk.tar.gz</a></li>
</ul>

<p>Eclipse update site : <a href="http://download.eclipse.org/modeling/tmf/xtext/updates/composite/milestones/]">http://download.eclipse.org/modeling/tmf/xtext/updates/composite/milestones/</a><br />
IDEA plug-in repository : <a href="http://download.eclipse.org/modeling/tmf/xtext/idea/2.9.0.beta5/updatePlugins.xml">http://download.eclipse.org/modeling/tmf/xtext/idea/2.9.0.beta5/updatePlugins.xml</a></p>


					<br/>
				</div>
			
				<div class="post">
					<h2>XtextCON 2015 - Final Program Online<small>&nbsp;&nbsp;&nbsp;Mar 31, 2015 (Sven Efftinge)</small></h2>
					<p>We are happy to announce the final program for XtextCON 2015. The conference now features 34 sessions with 27 speakers from different countries. Here is an excerpt of lately added sessions:</p>

<ul>
  <li><em>Oomph, Eclipse the Way You Want It</em> (Ed Merks, Eike Stepper),</li>
  <li><em>Xtext editors in JavaFX applications</em> (Tom Schindl),</li>
  <li><em>The Future of Xtext</em> (Sven Efftinge, Sebastian Zarnekow)</li>
</ul>

<p>The conference also covers graphical diagramming topics, such as:</p>
<ul>
  <li><em>Enhancing Graphical Editors with Xtext</em> (Miro Spönemann),</li>
  <li><em>Lightweight Diagrams for Your DSLs</em> (Christian Schneider),</li>
  <li><em>Graphical Views with FXDiagram</em> (Dr. Jan Köhnlein)</li>
</ul>

<p>In addition to those technical sessions, there will be case studies from different industries, e.g.:</p>
<ul>
  <li><em>Model based migration of legacy software</em> (Arjan Mooij),</li>
  <li><em>Sustainable Service Design through Xtext</em> (Dr. Michael Bischoff),</li>
  <li><em>EAI and Xtext DSLs</em> (André Lehner, Dietmar Stoll)</li>
</ul>

<p>There is much more to discover <a href="http://xtextcon.org">on the website</a>. And don’t forget to register!</p>

<h2 id="xtext-clinic">Xtext Clinic</h2>

<p>In addition to the conference program, the Xtext committers will again run the Xtext Clinic. This is an offer to the attendees to make an appointment for a one hour session, where individual Xtext-related problems and challenges can be discussed and solved. The clinic has been utilised a lot last year with very positive feedback. <br />
So in case you are going, don’t hesitate and make an appointment!</p>

<p>Hope to see you in May!</p>

					<br/>
				</div>
			
				<div class="post">
					<h2>Xtext 2.8.0 Released<small>&nbsp;&nbsp;&nbsp;Mar 11, 2015 (Sven Efftinge)</small></h2>
					<p>The team is proud to release Xtext &amp; Xtend 2.8.0. The new release comes with over 260 bugfixes and enhancements, the runtime performance as well as the tool performance has been improved significantly. Version 2.8.0 is the best Xtext &amp; Xtend ever! :-)</p>

<p>For more details please have a look at the <a href="/Xtext/releasenotes.html#/releasenotes/2015/03/11/version-2-8-0">release notes</a>.</p>

<h3 id="intellij-support">IntelliJ Support</h3>

<p>In parallel to the 2.8.0 release we have been very busy with working on support for IntelliJ IDEA, which comes along nicely. We will announce a public BETA in a couple of weeks. Please stay tuned for this.</p>

<h3 id="xtext-survey">Xtext Survey</h3>

<p>Please take part in our brief <a href="http://survey.xtext.org">survey on your Xtext usage</a>. We really need this information to better plan future developments. It’s just five minutes of your time, you can skip any questions you don’t like to answer and you can even win an iPad or a ticket for <a href="http://www.xtextcon.org">XtextCON</a>. Thx!</p>

					<br/>
				</div>
			
				<div class="post">
					<h2>Xtext 2.7.3 is out!<small>&nbsp;&nbsp;&nbsp;Nov 20, 2014 (Sven Efftinge)</small></h2>
					<p>We have just released version 2.7.3 of Xtext. It comes with some important bugfixes and is recommended for any 2.7.x users.</p>

<p>Here is the <a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;classification=Modeling&amp;classification=Tools&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;j1=OR&amp;list_id=10516978&amp;product=TMF&amp;product=Xtend&amp;query_format=advanced&amp;status_whiteboard=v2.7.3&amp;status_whiteboard_type=allwordssubstr">full log</a>.</p>

					<br/>
				</div>
			
				<div class="post">
					<h2>Xtext 2.7.0 Available<small>&nbsp;&nbsp;&nbsp;Sep 2, 2014 (Sebastian Zarnekow)</small></h2>
					<p>We proudly announce Xtext 2.7.0. The new version includes many improvements, new features and bugfixes. Also the crucial parts of the Xbase APIs have left the incubator status and are no longer considered provisional. More information about the changes in 2.7.0 can be found in the <a href="/Xtext/releasenotes.html#/releasenotes/2014/09/02/version-2-7-0">release notes</a>.</p>

<p>Special thanks go to all those who contributed to this release: Anton Kosyakov, Dennis Huebner, Holger Schill, Jan Koehnlein, Jan Rosczak, Jörg Reichert, Knut Wannheden, Michael Vorburger, Moritz Eysholdt, Ralf Kretzschmar-Auer, Sebastian Zarnekow, Stefan Oehme, Stéphane Galland, Sven Efftinge, Thomas Fritsch, and Vladimir Piskarev.</p>

<p>We’re also very grateful for the feedback that we get everyday. It helped us to get where we are now.</p>

					<br/>
				</div>
			
				<div class="post">
					<h2>Xtext 2.6.0 Available<small>&nbsp;&nbsp;&nbsp;May 21, 2014 (Sven Efftinge)</small></h2>
					<p>We are happy to announce the 2.6.0 release of Xtext. It includes many bugfixes, improvements and new features. Have a look at the <a href="/Xtext/releasenotes.html#/releasenotes/2014/05/21/version-2-6-0">release notes</a> for more details.</p>

					<br/>
				</div>
			
		</div>
  	</div>
</div>
    
    <footer class="site-footer">
  <div id="extra">
    <div class="inner">
      <div class="container">
        <div class="row">
          <div class="span6">
            <h3 class="footer-links-header">Quick Links</h3>
            <ul class="footer-links clearfix">
              <li><a href="http://www.eclipse.org/legal/privacy.php">Privacy Policy</a></li>
              <li><a href="http://www.eclipse.org/legal/termsofuse.php">Terms of Use</a></li>
              <li><a href="http://www.eclipse.org/legal/copyright.php">Copyright Agent</a></li>
              <li><a href="http://www.eclipse.org/legal/">Legal</a></li>
            </ul>
            <ul class="footer-links clearfix">
              <li><a href="http://www.eclipse.org">Eclipse Home</a></li>
              <li><a href="http://marketplace.eclipse.org/">Market Place</a></li>
              <li><a href="http://live.eclipse.org/">Eclipse Live</a></li>
              <li><a href="http://www.planeteclipse.org/">Eclipse Planet</a></li>
            </ul>
          </div>
          <div class="span6">
            <h3 class="footer-links-header"><a href="https://twitter.com/xtext" style="color: white;">@Xtext</a> on Twitter</h3>
            <a class="twitter-timeline" href="https://twitter.com/xtext" data-widget-id="346625441290928128"
            data-chrome="noheader nofooter transparent"
            data-theme="dark">Tweets by @xtext</a>
            <script>
            !function(d,s,id) { 
              var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';
              if(!d.getElementById(id)) { 
                js=d.createElement(s);
                js.id=id;
                js.src=p+"://platform.twitter.com/widgets.js";
                fjs.parentNode.insertBefore(js,fjs);
              }
            }(document,"script","twitter-wjs");
            </script>

          </div>
        </div>
      </div>
    </div>
  </div>
  <a href="#" class="scrollup fadeOutRight animated" style="display: none;">ScrollUp</a>
  <!-- Le javascript
      ================================================== -->
  <!-- Placed at the end of the document so the pages load faster -->
  
  <script src="/Xtext/js/jquery-1.11.3.min.js"></script>
  <script src="/Xtext/js/bootstrap.min.js"></script>
  <script src="/Xtext/js/jquery.easing.1.3.js" type="text/javascript"></script>
  <script src="/Xtext/js/jquery.prettyPhoto.js" type="text/javascript"></script>
  <script src="/Xtext/js/twitter.js" type="text/javascript"></script>
  <script src="/Xtext/js/prettify.js" type="text/javascript"></script>
  <script src="/Xtext/js/lang-xtend.js" type="text/javascript"></script>
  <script src="/Xtext/js/lang-common.js" type="text/javascript"></script>
  <script src="/Xtext/js/custom.js" type="text/javascript"></script>
  <script src="https://apis.google.com/js/platform.js" async defer></script>
  <!--script type="text/javascript">
    var _gaq = _gaq || [];  
      _gaq.push([ '_setAccount', 'UA-2429174-3' ]);
    _gaq.push([ '_trackPageview' ]);
    (function() {
      var ga = document.createElement('script');
      ga.type = 'text/javascript';
      ga.async = true;
      ga.src = ('https:' == document.location.protocol ? 'https://ssl'
          : 'http://www')
          + '.google-analytics.com/ga.js';
      var s = document.getElementsByTagName('script')[0];
      s.parentNode.insertBefore(ga, s);
    })();
  </script-->
  <script src="/Xtext/js/coverflow.min.js" type="text/javascript"></script>
  <script>
      $(function() {
        $('#coverflow').coverflow({
          active : 1,
          visibleAside: 2,
          overlap : 0.5,
          scale : 0.9,
          angle : 20,
          trigger : {
            "itemfocus" : true,
            "swipe" : true,
            "mousewheel" : false
          }
        });
        $('#coverflow :hidden').toggle();
        $(window).resize(function() {
          $('#coverflow').coverflow();
        });
      });

  </script>
</footer>


  </body>

</html>
