This website uses cookies for visitor traffic analysis. By using the website, you agree with storing the cookies on your computer.More information

Posts tagged: JVx

Nightly build binaries

We build all our OSS projects automatically every day, but only JVx binaries were available for download so far. We wanted to let you know that we added JVx.vaadin and JVx.help to the nightly-build download area. Check https://dev.sibvisions.com/jvx.nightly/ to get access to our nightly build binaries.

Currently we only push JVx snapshot binaries to maven central, but we'll do the same with JVx.vaadin or online help in a few weeks. So keep reading this blog to get the latest news or follow us on Twitter.

JVx with vaadin UI and server-side push

Vaadin supports "push" - since 7.1 - but JVx doesn't have an API for that. It's technology dependent and we usually not need it on client-side of an application. It would be useful for the server-side of JVx applications, but that's a different thing. I want to write about server-side push for UI changes.

If you use threads in your application, to update the UI, it's not a problem if you use a desktop technology like Swing UI. The UI is always up-to-date. If you use vaadin UI, it's not the case, because vaadin UI runs on an application server (= server machine) and vaadin client runs in your browser as Javascript code (= client machine). The thread runs on the server machine and doesn't update the client machine automatically. The client retrieves all changes with next client request. This is sometimes too late. With server-side push it's possible to update the client machine immediate, if you use pure vaadin.

With our next vaadin UI release, it's also possible to use server-side push of vaadin to update the client machine. It's very easy to use and also is technology independent, but we didn't introduce new APIs :)

How it works?

Create a new thread, through your factory and use invokeLater to update the UI. You always should use invokeLater to update the UI (no difference if you use swing or other desktop technologies).

UIComponent.invokeInThread(new Runnable()
{
    public void run()
    {
        try
        {
            while (!ThreadHandler.isStopped())
            {
                Thread.sleep(2000);
                               
                UIComponent.invokeLater(new Runnable()
                {
                    public void run()
                    {
                        iCount++;
                                               
                        label.setText("Push: " + iCount);
                    }
                });
            }
        }
        catch (InterruptedException ie)
        {
            info(ie);
        }
    }
});

If push is enabled, above code pushes the UI changes immediate to the client machines. To enable server-side push, simply add following to your servlet configuration in web.xml:

<init-param>
  <param-name>pushmode</param-name>
  <param-value>automatic | manual</param-value>
</init-param>

<async-supported>true</async-supported>

It's also possible to use vaadin push without JVx' mechanism (pure vaadin). To see how this works, read following issue: Server-side refresh.

JVx' area redesign

Our new JVx' pages are online: http://www.sibvisions.com/jvx

We reduced everything to a bare minimum and it's now much better than before. We added missing information like usage with Maven, Nightly builds, repositories for our demo application. The demo application is now up-to-date. We replaced our showcase application with our new ERP demo application.

We have a new JVx' video that shows all JVx features and projects like Online Help.

Have fun with JVx :)

Our brand NEW Demo application is online

Our good old showcase application was the first JVx application, developed in 2008. It showed some features of JVx but wasn't a real-world application. And of course, it was a small application :)

Some month ago, we decided to create a new real-world application. And what's better for JVx as an ERP system?
So we developed an ERP application :) It's not too feature-rich but demonstrates the full power of JVx.

It's the first application that contains all projects around JVx. The application runs as Java Applet, Webstart (applet or application mode), HTML5 (based on vaadin 7.1), mobile REST server for mobile clients (native iOS and Android) and our rewritten Online Help. Oh, and the built-in JVx REST interface. The application is a multi-user application with a user/role management.

The ERP system demonstrates a real-world Single Sourcing approach. A fat backend with a smart frontend and it supports mobility strategies.

If you want more information about JVx and UI independent application development, visit our talk at W-JAX (Tuesday, 10:15 to 11:30, room Lillehammer)

Thanks Stefan for your great work!

Try out our new application:

http://demo.sibvisions.org/demoerp/ (Applet)
http://demo.sibvisions.org/demoerp/web/ui (vaadin based)
http://demo.sibvisions.org/demoerp/help/ (vaadin based)

Use following credentials (Username = Password):

Manager: manager
Sales person: sales

The whole source code of the application is online and available on SourceForge.

Feel free to send us your feedback!

JVx First Application is available

Our JVx First Application is now available on SourceForge. In the past, we only had zip archives that contained our first application. Now it should be easier for you to start with JVx if you don't use our maven archetype.

The project site is: http://sourceforge.net/projects/jvxfirstapp/

The repository contains an Eclipse project that is ready-to use. The application itself is a database application. Please start the database before you start the application. The database is available and stored in db folder. Simply execute db/startHSqlDB.bat if you use Windows or start it manually on other OS'.

Our First Application is a very simple JVx application and demonstrates first steps without complex use-cases. It simple demonstrates user authentication via XML security manager and CRUD operations with a database table. But the project also contains a JUnit Test that shows how you could test your business logic.

A more complex application will be available in the next days. It's our Demo ERP. This application will demonstrate Swing UI, Vaadin UI, Online Help and more. It's a "real world" showcase that shows the full power of JVx.

VaadinUI 1.0 with JVx Archetype

If you want to use VaadinUI 1.0 with your maven project it's not an easy task because VaadinUI is not available via maven repositories - right now. But I want to show you an easy way to use VaadinUI 1.0 together with JVx Archetype 1.2.0.

Simply create a new maven project (my IDE is Eclipse) based on JVx Archetype 1.2.0. This archetype references JVx 1.2. Older versions are not compatible with Vaadin UI 1.0 - because of new features in JVx' launcher interface. In order to use Vaadin for JVx applications, add following dependencies to the pom.xml of your server project:

<dependency>
        <groupId>com.vaadin</groupId>
        <artifactId>vaadin-server</artifactId>
        <version>${vaadin.version}</version>
</dependency>
<dependency>
        <groupId>com.vaadin</groupId>
        <artifactId>vaadin-client-compiled</artifactId>
        <version>${vaadin.version}</version>
</dependency>
<dependency>
        <groupId>com.vaadin</groupId>
        <artifactId>vaadin-client</artifactId>
        <version>${vaadin.version}</version>
        <scope>provided</scope>
</dependency>
<dependency>
        <groupId>com.vaadin</groupId>
        <artifactId>vaadin-themes</artifactId>
        <version>${vaadin.version}</version>
</dependency>
<dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.4</version>
        <scope>provided</scope>
</dependency>

Set the global property in parent project pom.xml:

<properties>
        <jvx.version>1.2</jvx.version>
        <vaadin.version>7.0.6</vaadin.version>
</properties>

Because Vaadin runs on server-side, our client has to be deployed on server-side as well. Change pom.xml of your war project:

<dependency>
        <groupId>${project.parent.groupId}</groupId>
        <artifactId>${project.parent.artifactId}-client</artifactId>
        <version>${project.parent.version}</version>
</dependency>

This is not a perfect solution because jvxclient.jar will be added. This lib is not necessary because jvxall.jar is already available - but also not a problem!

The last step is the integration of JVx' VaadinUI. There are many solutions to integrate external libraries but maven is not a friend of external libraries. Using system scrope is evil and such libraries won't be added to war files. Deploying external jars to a local maven repository works but why should we do that? I did decide to use sort of a local maven repository placed in my project with following file structure in my server project:

mvn_repo_project

The integration in pom.xml of server project:

<repositories>
 ...  
 <repository>
    <id>in-project</id>
    <name>External libs</name>
    <url>file://${project.basedir}/lib</url>
 </repository>
</repositories>

Finally we need additional dependencies (server project):

<dependency>
        <groupId>com.sibvisions</groupId>
        <artifactId>jvxvaadin-client</artifactId>
        <version>1.0</version>
   </dependency>
<dependency>
        <groupId>com.sibvisions</groupId>
        <artifactId>jvxvaadin-server</artifactId>
        <version>1.0</version>
   </dependency>
<dependency>
        <groupId>com.sibvisions</groupId>
        <artifactId>jvxvaadin-themes</artifactId>
        <version>1.0</version>
</dependency>

The last integration step is the modification of web.xml in our war project:

<!-- Vaadin UI -->
 
  <servlet>
    <servlet-name>VaadinServlet</servlet-name>
    <servlet-class>com.sibvisions.rad.ui.vaadin.server.VaadinServlet</servlet-class>
               
    <init-param>
      <param-name>UI</param-name>
      <param-value>com.sibvisions.rad.ui.vaadin.impl.VaadinUI</param-value>
    </init-param>
               
    <init-param>
      <param-name>widgetset</param-name>
      <param-value>com.sibvisions.rad.ui.vaadin.ext.ui.Widgetset</param-value>
    </init-param>
               
    <init-param>
      <param-name>main</param-name>
      <param-value>com.sibvisions.apps.myproject.MainApplication</param-value>
    </init-param>
  </servlet>
       
  <servlet-mapping>
    <servlet-name>VaadinServlet</servlet-name>
    <url-pattern>/vaadinui/*</url-pattern>
  </servlet-mapping>

  <servlet-mapping>
    <servlet-name>VaadinServlet</servlet-name>
    <url-pattern>/VAADIN/*</url-pattern>
  </servlet-mapping>

That's it.

Use the war project together with an application server in Eclipse and enter http://localhost/myproject/vaadinui/ in a web browser to start your application with VaadinUI - with debugging support. Create a war file, deploy it and it will work without problems.

VaadinUI 1.0

Our new vaadin UI is available. It's the first release and it's awesome.

Get the binaries from our project site. It's licensed under Apache 2.0 and free for all.

The installation is very simple:

  • Download jvxvaadin-1.0.zip
  • Unzip the archive
  • Add all files to your existing JVx application
  • Change Deployment descriptor (web.xml) and replace simpleapp with your application

Have fun ;-)

JVx 1.2 is out

We released JVx 1.2 today - as planned ;-)

The binaries are available on SourceForge or via Maven central. We also updated our Archetype to version 1.2.0 and it should be available in Maven central in the next days.

We told you that the release contains about 90 tickets. The real number of changes is 123.
Check the changelog for a complete list.

Next version will be 2.0

We did decide that version 1.2 is the last release before 2.0. It's not because of new killer features or big API changes.
The higher version number should represent the maturity of JVx.

JVx was started in 2008 and the low version numbers were fine for our own goals, but our users asked for bigger steps. If we compare our 1.2 with other frameworks, we could use 5.0 without problems.

The version 2.0 will be a smaller feature release that changes MetaData handling on server-side. We'll introduce a new caching mechanism that allows manual change of storage metadata.

We plan the release for the end of this year - without guarantee.

We also plan maintenance releases starting with 2.0

Currently, we don't fix bugs in old JVx releases. We only fix bugs in our development version. We offer nightly builds and maven snapshots and we thought that's enough, but some users want to keep old releases. No worries, we'll do our best to make you happy!

W-JAX 2013 - JVx on stage

We'll be live on stage at W-JAX '13 in Munich.
Our session is scheduled for Tuesday, 5th November - 10:15 to 11:30.

We'll talk about UI independent application development in practice

Are there enough web and UI frameworks for us developers? Absolutely! There are really cool web UI frameworks like GXT or Vaadin. There are swing and JavaFX for desktop apps and many others. Don’t forget all web frameworks! Which UI framework is the best for your next project and works with browsers and OS‘ in 5 or 10 years? Which investment is future save? The only solution is a technology and UI independent framework. Such a solution is JVx (Apache 2.0). It is a full-stack app framework, designed as library. Develop UI independent and decide which UI technology is best for you. If you prefer Swing, start your app as Swing Application. If it’s Vaadin, use Vaadin. Don’t rewrite your application, just choose the preferred UI technology!

Come and talk with us

Project news [2]

This is an update of Project news.

We completely replaced our good old Java OnlineHelp (GXT version) with a new Vaadin implementation. It's based on Vaadin 7 and has some amazing new features, like full-text search. No worries, the new version supports the same file structure as our old version. The upgrade procedure is simple: Keep your structure directory and delete all other files. The binaries will be available in the next days.

We also removed all other GXT based projects because we switched the web technology. We think vaadin is the better choice and replaced our previous webUI with vaadinUI. Of course, it's not a 1:1 replacement but the first release is awesome. We'll release the binaries next week.

Our old webUI project is still alive because it contains our headlessUI. This project is still important and the base of our project JVx.mobile and some other projects that don't need a UI. This project makes it possible to start a JVx application on server-side. If you create REST or SOAP services, our headlessUI might be the right choice?

Our vaadinUI and headlessUI are sub projects of JVx!

That's all for today!