The next release of our JVx' vaadin UI is available. It's not a big update but an important one because vaadin was updated to 7.5.0 and we support CORS out-of-the-box. We also have some annotations for easier application deployment.

The best thing for most of you is that starting with 1.3 our vaadin UI can be found on maven central.

Simply add the dependency:

We also upload snaphsots of vaadin UI, starting with current 1.4 branch
Simply configure the repository:

and use following dependency:

The release files are also available on SourceForge.

The complete Changelog.

We've added some annotations to our vaadin UI to support UI configuration without web.xml (deployment descriptor).

Check this:

The example demonstrates a minimalistic JVx application with vaadin UI. It's like a standard vaadin application with one additional annotation:

The main parameter defines the JVx application class. It's the inner class MyApplication, in our example.

It's that easy!

We're happy to announce that JVx 2.3 is available. The minor version update is more than a small update. It
comes with a bunch of new features. We think it's an update worth:

Here's the list of changes

• Support linking with RoboVM

  It wasn't possible to create iOS applications with JVx because it had an internal problem. With 2.3 it will work.
  There's still a problem with RoboVM because JVx contains swing UI but if you remove the UI from the jar, everything
  will work!

• Download via REST

  It's now possible to call actions which will return instances of IFileHandle, via generic REST services. The content
  will be sent back as binary stream (download).

• CORS for REST

  Simply set the parameter: cors.origin to the allowed domain names (a comma separeted list).

• Connection pooling

  It was possible to use connection pooling with JVx but with some limitations. The current support is an official solution without demand for additional source code. The only thing you should consider is that the initialization of the database should be moved to an event. The DBAccess class got new methods: eventConfigureConnection and eventUnconfigureConnection.
  Use configure to prepare the database session before you

• Server-side hooks for event processing

  JVx 2.3 got invokeLater for server-side calls and we introduced the new interface ICallHandler.
  It has some very useful methods for better server control:

  public CallEventHandler<IBeforeFirstCallListener> eventBeforeFirstCall();
  public CallEventHandler<IAfterLastCallListener> eventAfterLastCall();
  public CallEventHandler<IBeforeCallListener> eventBeforeCall();
  public CallEventHandler<IAfterCallListener> eventAfterCall();

  public void invokeAfterCall(Runnable pRunnable);
  public void invokeAfterLastCall(Runnable pRunnable);
  public void invokeFinally(Runnable pRunnable);

• Better Deployment support for VFS

  We had some crazy tweaks especially for some application servers with virtual file systems like JBoss. We removed the dirty code and replaced it with a more generic approach and now we have nice support for VFS and no more problems with WildFly.

• Filter/Sort events added to IDataBook
  public DataBookHandler eventBeforeFilterChanged();
  public DataBookHandler eventAfterFilterChanged();

  public DataBookHandler eventBeforeSortChanged();
  public DataBookHandler eventAfterSortChanged();

• Integration of external property files

  It's possible to include external property files into your application' config.xml:

  <application>
     <include>/configuration.properties</include>
     <securitymanager>
        <accesscontroller>dummy value</accesscontroller>
     </securitymanager>
     <property name="property.value" value="${value}"/>
  </application>

  The property file (configuration.properties):

  securitymanager.class = com.sibvisions.SecurityManager
  securitymanager.accesscontroller = com.sibvisions.AccessController
  value = value1

  The virtual result for reading values:

  <application>
    <securitymanager>
      <accesscontroller>com.sibvisions.AccessController</accesscontroller>
      <class>com.sibvisions.SecurityManager</class>
    </securitymanager>
    <property name="property.value" value="value1"/>
    <value>value1</value>
  </application>
• Autodetection of tnsnames.ora

  It was possible to set the system property oracle.net.tns_admin for an oracle JDBC driver. New JVx tries to find the location automatically and sets the property if path was found.

• API changes

  We did two smaller API changes. The first one:

  LoggerFactory.destroy is now public

  The class AbstractSessionContext was removed without replacement. The only method, getMasterSession, was moved to ISessionContext. It's now easier to access the current master session in life-cycle object. It shouldn't be a problem for you because AbstractSessionContext was meant as internal class and not for public use. If you had a cast to AbstractSessionContext, simply remove the cast and everything will be fine.

We also have some smaller changes and bugfixes for you, but above list only contains the most important changes. For a full list of changes, please read the Changelog

Both products are code complete and JVx passed all tests. We're in the test phase with VisionX and do some smaller fixes, but it looks very stable.

We set the official release of VisionX 2.2 to August, 17th. We will release JVx 2.3 during the coming week (~ August, 7th).

VisionX 2.2 will come with some great new features like Java 8 + Multi-IDE support and our new MorphPanel.

MorphPanel?

It's a new UI component. You can use it to visualize a table of records (grid) and show record details as form in a tab area, as split panel, a popup or as replacement of your grid (= web mode).

It's soo useful. Usually you would create two or more screens for the same use-case but one screen with one MorphPanel is enough with VisionX 2.2.

A simple use-case: You have one master-data screen and want to show an edit screen for the records on double click or button click. You need one screen for showing master-data and another screen for the edit form. The master screen opens the edit screen with an additional parameter, to show the correct record in the edit screen... (boring).

Simply add a MorphPanel to your master-data screen, set Popup mode, design the popup and you're done. This is great for desktop applications and awesome for web applications!

Details and screenshots will follow!

Interested?

Get ready for VisionX 2.2.

You know that we use SourceForge (SVN services) for our open source projects like JVx, Vaadin UI, JavaFX UI, Online Help and some others.

The whole platform had big problems and so we couldn't use our repositories as usual. It wasn't a real problem for us because we had backups and our local repositories were up-to-date, but it wasn't possible to build snapshots or create nightly builds.
Our build infrastructure is directly connected to our SVN repositories and so we had no chance to build our projects.

Since yesterday, all our repositories are online. We made some tests and everything was fine. We lost one full day (July, 17th) because SourceForge stopped working at July, 17th and backups were from July, 16th. But also not a problem because we had local copies.

We did some migration checkins and now, everything is online. Our SF repositories are up-to-date.
Our "nightly build" was started some minutes ago and everything was finished without problems.

So, we're back in the game.
(A big "Thank you" to all SF operators for their support, daily reports and countless hours of restoration)

Future?

We got some questions during last days and most of you asked us if it wouldn't be better to leave SF and use GitHub instead. We don't think this makes sense because such problems can happen with all providers - sure, they should never happen.

The migration effort from SF to GitHub is high and we don't have visible benefits. We know that git has some advantages compared to SVN but we don't need more than Source Code versioning and the checkin history. It's that simple. SF services aren't as fancy as GitHub services and the repository access via browser is better with GitHub, but this wasn't important for our decision.

It was important for us to use a big OpenSource provider and SF is a dinosaur in this area. We don't plan to leave SF but it's not impossible, e.g. if the environment changes.

Since last year we are offering an Eclipse Plugin that integrates  the JVx workflow into Eclipse. Now that EPlug 1.2 has been released, we believe it's long overdue to give you a guided tour of the experience that EPlug is offering.

Trial

We offer a free trial period so that you can test EPlug without any problems. The first time you start Eclipse with EPlug you will be asked if you'd like to only test EPlug, or if you'd like to select an already purchased Pro license.

When clicking the Trial button, a new trial license will be issued and you'll be able to evaluate EPlug with all features for 30 days.

'First Run' Wizard

One of the biggest usability improvements compared to previous versions is discoverability of how to use and activate EPlug. With the new version we have added a "First Run Wizard" which allows to directly activate EPlug on selected projects.

Usage

EPlug integrates seamlessly into Eclipse, but to use most of its features it has to be activated on each project you want to use it with. This can be done in the previously shown First Run Wizard, or by right-clicking a project and selecting "Activate EPlug" under "Configure".

From there on you will be able to use code completion, compile time checks and all the other features on this project.

Better and extended commands

A handful of commands are added by EPlug, which make it faster to navigate in JVx projects.

Go to complement class

It's often the case that you want to go from the server to the client class, or from the client to the server class. Most of the time in Eclipse this involves expanding trees and looking for the correct class in the Package Explorer. That is why we've implement the command "Go to complement class", which enables you to quickly jump from the server to client, or the other way round.

As you can see the command is available from the context menu, but you can also bind it to a key in the "Keys" preferences.

Open Declaration

The "Open Declaration" command, sometimes known by its key binding "F3", allows you to jump to the declaration of whatever is currently under the cursor. We've extended this command with the possibility to jump to the declaration of event handlers (actions), server methods and storage's. If the item underneath the cursor is not handled by our extension, the default "Open Declaration" command will be invoked.

The declaration:

Because we've extended the "Open Declaration" command, you can bind the "Open Declaration (EPlug)" command also to "F3" and enjoy faster navigating in your JVx files without any downsides.

DataBooks

The biggest and most important feature of EPlug is its support for data books. EPlug offers code completion, compile time checks and more for column names on remote and local data books.

Code completion

Everytime you want to get or set a value, or wire up an editor you will receive code completion suggestions with all column names that are in the databook, it doesn't matter if those are remote or added locally.

Compile time checks

Of course we also added compile time checks, which means that you can never mistype a column name ever again.

With the newest version, these compile time checks are even active while you type!

Text hovers

When hovering above a column name, a simple text hover will inform you about the type of the column.

Storage support

RemoteDataBooks require to have the correct name set so that the server side storage is found, of course we do also offer code completion, compile time checks, text hovers and hyperlinks for this.

The DataBook View

And last but for sure not least, with the newest version a feature has been added which I've been looking forward to for quite some time: The DataBook View. A view similar to the Outline view, which displays all databooks in the current file and all of its columns.

Actions/Events and server calls

Support for actions, events and server calls is the second big EPlug feature. For events and actions we support a very Lambda-like system that uses reflection and strings. Obviously the compiler was never able to understand this system and provide feedback or support for it, but with EPlug this has changed.

Code Completion

Whenever you want to wire up an event, you'll now receive code completion for all fitting methods in the used class.

Action methods:

Remote calls:

As you can see in upper image, we also provide a fast and convenient way to create methods if necessary.

Compile time checks

During compilation the actions, events and server calls are checked for their correctness, and if there is a problem it'll be reported to you.

You can also see the quick fixes for this problem, which do not only offer to create the missing method, but also suggesting methods with similar names in case a typo happened.

Text hovers, hyperlinks and refactoring support

Additionally EPlug provides text hover and hyperlink support, that means that you can now jump to the methods by using your mouse (Ctrl+Left Click) or the "Open Declaration (EPlug)" command. Refactoring support has also been added, which means that you can now rename action/event handlers without having to manually search for all uses and change those.

Resources

Dealing with resources can often be a pain in the neck, especially if you constantly have to look up the path and check if you're now using the correct image. Because we also felt these pains, we've added functionality to EPlug to make sure that working with resources becomes easy and painless.

Support for UIImage

Whenever you use UIImage methods, you can now enjoy code completion, previews of the images and compile time checks.

Preview:

Compile checks:

Generic resource completion

For all other resources, we do only offer a "generic" code completion system and no preview. Still, this is a huge help.

Comments

One of the more simple and not so obvious features of EPlug is that it allows to have code completion of the current class in comments, and also provides the JVx category separators.

Separator:

Action/call completion in comments:

VisionX support

Now we've arrive at the big final, support for VisionX. For all of you who do not know VisionX, it is our product for rapidly building applications from scratch or migrating already existing systems. It allows to build GUIs and the respective database backend within a matter of minutes. Even though VisionX allows you to build whole applications, from time to time you'll want to do something by hand and this is the great thing about VisionX, all projects and applications are automatically and by design already Eclipse projects. So all you need to do is import the project into Eclipse and start working on it. To improve this workflow further EPlug does offer various features.

Selection synchronization

The selection in Eclipse and VisionX can be automatically synchronized, so that whatever you're working on in the one application is also visible and selected in the other

Automatic applying of changes

VisionX will also automatically refresh its current view if you change a sourcefile in Eclipse, allowing to rapidly and verify changes in a workscreen without the need to manually reload the workscreen.

How and where to get it?

EPlug comes in two flavors, EPlug for JVx and EPlug for VisionX, both are available from the Eclipse Marketplace and can be installed and used freely for 30 days. Afterwards a license is necessary to keep using all features.

Our next JVx release is code complete (but not yet released). It was planned as smaller bugfix release but we have some cool new features, because it's sunny and warm outside

What's new?

• Connection Pooling support

  This is an awesome feature for JVx - not rocket science but was missing!

• File download via REST

  We did update RESTlet to 2.3.2 and recognized IFileHandle as transfer object. Simply call your action and return an IFileHandle and your REST client will receive the content.

• CORS support for REST

  Just sayin'

• WildFly deployment support

  ...Virtual Filesystem if "exploded" wasn't enabled

• tnsnames file support for Oracle
• Server-side call events

  It's a great feature but not for everyone of interest

We'll do some tests during the next week but it looks very stable right now.

The complete list of changes.

OpenShift is a PaaS product from Red Hat.
Read further details at Wikipedia or the product site.

It's of interest to us because it's easy to use, supports deployment of pre-created war files and it offers an application server (e.g. Tomcat, JBoss) and a database (MySQL, PostgreSQL) for your applications. OpenShift also has Vert.x as runtime platform if you won't use an application server. The configuration is super easy and your server is ready in around 5 minutes.

The access to your server is protected and you should use a specific client tool from RedHat for advanced configuration or an SSH client like putty.

The PaaS service is so nice because it's the perfect deployment platform for JVx applications. There's a free service for simple tests and maybe smaller applications because there are some limits for memory usage, CPU, and number of applications.

We made some tests with OpenShift and the result was as expected: Our applications did work without problems. Sure, the whole deployment procedure could be more end-user friendly but it wasn't designed for end-users without technical know-how, I guess. It's good enough for software developers or admins.

Our test

We created a new JVx application with VisionX (because it creates the database, has a GUI builder and creates the war file for us) and the application should run with VaadinUI on OpenShift. We didn't have any experience with OpenShift, but with other PaaS products, e.g. Heroku, Cloudbees, Jelastic, AWS.

First steps:

1. Registering an account (what else )
2. Creating a first application
3. Cartridge: Tomcat 7 (JBoss EWS 2.0)
4. Setting application name and domain
5. Adding MySQL 5.5 cartridge

Above steps were enough to run our OpenShift service(s).

Next was accessing the server via SSH client because we didn't install the RedHat client tool (We won't use client tools for cloud services - why the hell). Sure, we had to use another client tool for accessing the server via SSH, but it was working without installation: PuTTY (still strange). A nice web UI would be great... just my thoughts. We found a Java client but didn't test it.

So, what we did:

1. Creating private/public RSA keys with PuTTYgen
2. Configuring OpenShift (used the key from PuTTYgen TextArea because OpenShift didn't like other formats)
3. Testing connection

   Username was displayed in Application settings under SSH Code, e.g. ssh://<username>@app-domain.rhcloud.com/....
   Used the private key file for putty as key (Key authentication, without password)

Next task was, configuring the access to the database because SSH access was already working. It wasn't possible to access the database without tunnel - means, no direct (Internet) access from your client. This wasn't a real problem and PuTTY had support for port tunneling. Simply detected the IP address of the MySQL server. The hostname was set as environment variable and the command export displayed all variables. The variable OPENSHIFT_MYSQL_DB_HOST had all information and our tunnel was working. There's also a property for the MySQL Port but 3306 is default.

What was next?

Deployment.

This wasn't trivial because the platform expected source code and a maven project for automatic deployment. Wrong for us. But there's an official documentation for manual war deployment.

Short summary of steps

1. GIT clone
2. Delete src folder and pom.xml
3. GIT commit & push
4. Copy WAR file into webapps folder
5. GIT commit & push

You don't need git on your client, it's available in your terminal. But... as a developer, git is one of those standard tools...
It's also possible to upload the WAR file via SCP or SFTP...

Done...

Not really because our application was deployed without problems but it didn't work because the JDBC URL was wrong. We set the MySQL servername to localhost because of the tunnel!

Here's the original config.xml:

JVx has a nice feature which allows environment dependent settings and VisionX sets the environment automatically to prod. So, we simply changed the datasource to:

VisionX sets the environment to prod, if it creates a WAR file:

Sure, the solution isn't perfect because the MySQL hostname should be read from the environment variable.
Would be better:

But JVx doesn't support this syntax (right now) -> Feature Request.

Done. Really done.

The application works fine (Login as admin with password admin).

Here's a screenshot, for the case that our OpenShift service isn't running:

OpenShift ERP with JVx and VaadinUI

Our JVx connection implementation for vert.x is up-to-date. It's now based on vert.x 3.0. We support http and socket connections - no API changes.

Updating to vert.x 3.0 from 2.2 was not funny because package structure was changed and some APIs as well. Whatever, it's working.

If you're interested in our vert.x implementation, check the github repository because we don't offer binaries.

We're happy to announce that our JavaFX UI 1.0 was released.

The release contains all planned features and some more. We have the complete MDI implementation, Zoom support for windows and the scene, a custom scene style, custom comboboxes and much more.

MDI control		Combobox

Styled Scene

Table format (cells)

Zoom

Master/Detail with Tables and Tree

All custom controls are available as separate library, JFXtensions. This library will work without JVx because it has no dependency to JVx. Simply use our MDI implementation or zoom feature for your own JavaFX application without using JVx.

Jar files are available at SourceForge or Maven central.

Our next steps?

We'll integrate the UI in our product VisionX to allow Live Preview with JavaFX. The first update release with version number 1.1. will contain smaller bugfixes and improvements based on user feedback.

So, send us your Feedback if you use our library.