We tried to improve the UX of our tool VisionX in the last weeks. The current concept is wizard based and all wizards are kept very simple. This concept works well but requires curiosity. It would be better go guide the user through the application and show the features.

Some software tools use strict guides and explain the application with step-by-step instructions. This is nice but also boring because you can't play around. We tried to add a sort of a guide but without restrictions.

The first preview of this new concept is available as YouTube video. We're not sure if this solution will be available in the next release but our testers love it. It fills the gap between wizards and the question: What should I do next?

Here's the screencast:

The next version of our flagship VisionX will be available tomorrow - Feb 5th, 2016. The version number is nice because 2 could be the month and 2+3 = 5

We invest more time/resources/work than ever before in this version. It has many new features and great improvements. All included open source libraries were updated and offer additional features because not all available library features/APIs are covered by VisionX.

So what's new?

• Vaadin 7.5.7

  The open source project JVx Vaadin UI was updated to Vaadin 7.5.7 and the UI implementation got many performance tunings. It's now significant faster than before - up to 5 times faster. The performance boost depends on your UIs because it makes no difference if you only have two input fields in your screen. But if you have large screens with Tabs and many input fields, it will rock. The API got support for FontAwesome and Vaadin font icons.

• HTML5 Live Preview

  The live preview now supports an external CSS file. It's super easy to change the style of your application while creating it with VisionX.

• HTML5 Live Reload

  This feature automatically reloads changed screens in the browser after you've changed it with VisionX. Simply use add URL Parameter liveReload=true. This features save click time and is great if you have multiple screens conntected to your workstation.

• Responsive coporation layout

  Our corporation application layout is now responsive and fully customizable.

  full mode		small mode
  mini mode		mini mode (menu)

  Use the API to show/hide the menubar or the sidebar. Add custom or remove default buttons.

• Support for custom code format rules

  It's possible to use your custom code formatting rules. The rules are based on Eclipse Code Formatter and all Eclipse (Luna) options will work with Eclipse.

• Morph Panel improvements

  The Morph Panel is a one-for-all solution. It was introduced in VisionX 2.2. We improved the popup mode, e.g. if you double click the table, the popup will be opened if you don't use the navigation. We added more APIs for power users.

• No more automatic database changes

  VisionX doesn't change the database objects automatically. It's your decision:

  Modify fields

  Delete screen

• Java 8 u60

  VisionX runs with Java8 update 60.

• Action editor automatic scrolling

  The action editor now automatically scrolls to the input field if it's not visible. It's not a big thing but creates great UX.

• Automatic import organisation

  VisionX automatically removes unused imports from the source files. This is an optional feature and can be disabled.

• Single line javadoc for fields

  The Javadoc for fields will be written in a single line (if possible). This feature is optional an can be disabled.

• Better customizing support

  VisionX changed the class loading mechanism of customizers and controls. It'll be possible to use your custom controls without any tricks. It's possible to customize VisionX for your needs.

• Mobile application creation (optional AddOn needed)

  This feature is awesome because it makes it be possible to create a mobile app from your application in under 5 minutes.

  JavaFX mobile LIVE CSS hacking

• Additional licensing options

  User based, Subscription based, Floating, individual.

  Please contact our Sales Team for more details.

All customers will find the new version in their download area!

Some time ago, we changed the hardware of our VM server. We replaced the RAID controller with an Adaptec 6805 because the old controller had some problems. The server run with ESXi 5.1.

The problem with our Adaptec controller was that ESXi didn't support it out-of-the-box. It was supported in general but the driver was not included. We thought that the new ESXi 6 could contain the driver, but it didn't. So we had to create our own ESXi image with the Adaptec driver.

We thought it shouldn't be a problem because there was much documentation about custom images:

https://blogs.vmware.com/vsphere/2012/04/using-the-vsphere-esxi-image-builder-cli.html
http://www.virten.net/2015/03/esxi-6-0-image-for-intel-nuc/
(DE) https://www.thomas- krenn.com/de/wiki/Individuelles_ESXi_5....

Some problems:

• We tried to create an image for version 6
• We used the free version of ESXi with all its limitations

A problem was that the documentation references an "offline software depot". You can download the offline depot for the paid version but it's not available for the free version - not as simple download. No offline deplot means no custom image - right? Not right, because it's also possible to use an online depot.

The problem was that the documentation didn't contain a full description. We found some hints in different blogs but no complete description.

Here are the steps how we created our custom ESXi 6 image with Adaptec 6805 driver:

Downloads

• ESXi

  https://my.vmware.com/en/group/vmware/evalcenter?p=free-esxi6

• PowerCLI 6

  https://my.vmware.com/group/vmware/get-download?downloadGroup=PCLI600R1

• Adaptec driver

  http://partnerweb.vmware.com/comp_guide2/detail.php?deviceCategory=io&productid=19667

Useful PowerCLI Documentation:
https://pubs.vmware.com/vsphere-55/index.jsp#...ve-EsxSoftwarePackage.html

Image creation

• Install PowerCLI 6 (and all required dependencies)
• Unzip the Adaptec driver to e.g. C:\temp\VMServer6\
• Run PowerCLI as Administrator (sometimes, first launch of PowerCLI isn't working - simply close/run again)
• Execute following commands
  # Preconfigure
  Set-ExecutionPolicy RemoteSigned
  cd c:\temp\VMServer6\

  # Use online depot
  Add-EsxSoftwareDepot https://hostupdate.vmware.com/software/VUM/PRODUCTION/main/vmw-depot-index.xml
  # Add offline bundle for adaptec driver
  Add-EsxSoftwareDepot aacraid-6.0.6.2.1.41024-offline_bundle-2915492.zip

  # Check added depots
  $DefaultSoftwareDepots

  # Lists all ESXi-6.* profiles
  Get-EsxImageProfile -Name "ESXi-6.*"

  # Sets the base profile
  New-EsxImageProfile -CloneProfile "ESXi-6.0.0-20160104001-standard" -name "ESXi-6.0.0-20160104001-standard-Adaptec" -Vendor "rjahn@SIB" -AcceptanceLevel "CommunitySupported"

  # Lists all included drivers
  Get-EsxSoftwarePackage -Name "*aacraid*"

  # Adds adaptec driver from offline bundle
  Add-EsxSoftwarePackage -ImageProfile "ESXi-6.0.0-20160104001-standard-Adaptec" -SoftwarePackage scsi-aacraid

  # Creates boot image
  Export-ESXImageProfile -ImageProfile "ESXi-6.0.0-20160104001-standard-Adaptec" -ExportToISO -filepath C:\temp\VMServer6\build\ESXi-6.0.0-20160104001-standard-Adaptec.iso

  # Creates Bundle
  Export-ESXImageProfile -ImageProfile "ESXi-6.0.0-20160104001-standard-Adaptec" -ExportToBundle -filepath C:\temp\VMServer6\build\ESXi-6.0.0-20160104001-standard-Adaptec.zip

Version numbers may be different, but the procedure should work for you as well. The online depot:
https://hostupdate.vmware.com/software/VUM/PRODUCTION/main/vmw-depot-index.xml

was the most important thing. All other steps can be found in the standard documentation.

Yesterday, we've released JVx 2.4, VaadinUI 1.4, HeadlessUI 1.1 and JVx vert.x 3.0.

Headless UI and JVx vert.x are maintenance updates because of JVx changes. JVx 2.4 is a bugfix release with some new cool features and VaadinUI is a performance tuning and bugfix release.

JVx and VaadinUI are available on Maven central. The other releases are hosted on SourceForge.

What's new in JVx 2.4?

• Thread safety

  DataBook (MemDataBook, RemoteDataBook) are now Thread safe. It wasn't guaranteed before 2.4.

• Support for Boolean and Arrays (Oracle)

  JVx' OracleDBAccess supports Boolean DataTypes via JDBC calls and Arrays as well. We wrapped the functionality in our existing API and it makes no difference for you. Arrays are wrapped as List of IBeans.

• Parameter changed event in WorkScreen

  The WorkScreen class got a new event: eventParameterChanged. It enables notification about parameter changes.

• New AbstractFactory

  We introduced AbstractFactory and changed all factory implementations. With AbstractFactory, it's possible to set custom factory properties. We use this new feature for vaadin UI. With new Vaadin UI it's possible to use the old Table or the new Grid implementation. Simply set a property for that.

• API change: IFactory

  The invokeInThread method now returns the Thread instance.

• FontAwesome support
• Automatic Record translation

What's new in Vaadin 1.4?

• Based on vaadin 7.5.7
• FontIcon support
• Grid support (experimental)

  Set the factory property: vaadin.component.legacy_table to true (via web.xml as init parameter or as URL parameter).

• Lazy loading of LinkedCellEditor

  Before 1.4, all LinkedCellEditors were loaded immediate. This was a performance impact. With 1.4 this was changed and data will be loaded, when needed.

• Performance tuning

  The performance is now about 5 times faster than before. We improved the performance because we reduced our CssExtension and reduced the database calls. You can feel the new performance

What's new in JVx vert.x 3.0?

It's based on Vert.x 3 and works with JVx 2.4.
(JVx vert.x is hosted on GitHub)

You can find all changes in the project Changelogs.
Happy coding!

Oracle doesn't use/define the SQL Type Boolean. You can't define a column in a table as Boolean. It's possible to use boolean in PL/Sql e.g. for procedures or functions but you can't call the function from SQL.

Example functions

It's possible to call:

but it's not possible to call:

or

(1 = true, 0 = false; boolean is mapped to integer in Oracle)

If you want to call a procedure or function which defines boolean parameters, it's not possible without tricks with Oracle JDBC driver. This is annoying.

We solved the problem in JVx 2.4 and it's now possible to call functions or procedures without tricks. Here's a "more complex" example. We define a function with an input parameter and a procedure with an input/output parameter in a package:

Now we use JVx' DBAccess to call the function and procedure.

The whole type mapping was done in OracleDBAccess and it's invisible for you. Simply use the API to call procedures or functions.

Some days ago, I wrote about our eTV project. The blog post had some pictures but no more details. I want to tell you some details about this project because it's simply awesome.

The project was a research project of our framework team and was started just for fun. The use-case was simple: Our room had 4 walls and 3 were full with pictures and world maps. Only one wall was empty. Why not using a flat TV for showing different content like livestreams, comic strips, images.

The idea was great and some days later, the last wall was full. A nice 43" flat TV was mounted.

We thought that a RaspberryPi could bring the content to the TV because it's a small device and fits behind the TV. Java works without problems on the Pi and JVx as well.

After all hardware pieces were ready, it was time to think about the software because a sort of control center was needed to implement some features. The plan was to write a simple server which has a set of commands like: open website, show image, play livestream, execute command, upload file, download file.

The server was implemented as simple socket server, with JVx. It executes pre-configured commands and has some important control features: take screenshot, next - previous window, get window list, close window. The server has no GUI and is more or less a window/process manager.

The server has no GUI, but we need a GUI to control the server. We wrote a simple JVx application as remote control. The remote control application was deployed on a Jetty application server (on the RasPi, with vaadin UI) and as mobile JavaFX application. Jetty runs fine on the RasPi and our vaadin UI as well.

The TV with RaspberryPi, streaming a Video from YouTube:

eTV YouTube Stream

After we were ready with the server, we tried to create a simple JVx demo application to demonstrate JVx on embedded devices. It was funny to use eTV for live streams or to show images, but what about real-world use-cases?

The idea was about a JavaFX application, running on the RasPi. The application could be a monitoring app for a warehouse with a nice looking frontend and a backoffice view for administration. It's usual to have a nice looking frontend and a not so nice looking backoffice part.

We've implemented an application for a big assembly hall. The application is a styled JVx application but still 100% JVx. We've used VisionX to create the UI:

VisionX design mode		TV mode

The application in VisionX is not 100% the same as on the TV because of the screen resolution, but it's the same source code and VisionX works with this application. The application on the TV hides the application frame and only shows the screen content, but this is a supported feature.

The UI technology is not JavaFX! We tried to use JavaFX but it wasn't possible because the RasPi had performance problems with the amount of nodes. It wasn't possible to reduce the amount of used nodes with standard JavaFX controls. Overclocking the Pi didn't solve the problem.

We simply switched to Swing and didn't have any performance problems. So, the UI technology is good old Swing. It works great in combination with the RasPi and we think the result is also nice!

The application is a monitoring application for different events, like performance, effort, pressure, temperature, aerodynamics, alerts. We did connect a temp sensor and two buzzers to get a better real-world experience and because it was easy to support with a RasPi. Initial setup:

Initial setup

The backoffice/backend was deployed as web application (Jetty on RaspberryPi, JVx vaadin UI) because it should be possible to use it on tablets or smartphones without native apps:

Backend view

The same UI on mobile phones:

Mobile view

Mobile view (no menu)

The application is a 100% JVx application with Swing UI and vaadin UI. Everything runs directly on the RaspberryPi.

We've used the whole eTV system as showcase application at DOAG conference in November:

eTV @ DOAG 2015

The results of our "research project" are awesome and eTV is a ready-to-use product. We didn't code one line of code to support different UI technologies and didn't have problems with resolutions of tablets, smartphones or the TV (#responsive).

Thanks to JVx it was super easy to create an amazing application.

Our (research) projects with JavaFX are almost finished. We have awesome results and everything is production ready. The only drop of bitterness is the performance of JavaFX on desktops and mobile devices, but this can be improved by Oracle. It's not in our hands.

What do we have?

We have

• a complete JavaFX UI for JVx
• a custom application frame for mobile applications
• Live CSS manipulation of installed apps (needs debug build)
• Complete Project export for JavaFX mobile projects (JavaFXPorts based gradle project),
  integrated in upcoming VisionX 2.3
• Remote Work-screen loading (via VisionX)
• JVx server runs without limitations on mobile devices
• JVx client runs on mobile devices (for network clients)

How does it look like?

I have some screenshots from two applications. The first one is a standalone JVx application. The whole JVx framework runs on the mobile device. The app is a remote control for our eTV project (it's a brand new side project of our research team).

The app was inspired by MS Metro style ... Windows8 style ... Modern ... Universal ... Windows Store ... Windows apps.

The main screen has some buttons to control our eTV and some buttons open a "popup" with additional options:

eTV Dashboard		eTV Window view
eTV Gallery

The second app will be shown as Video, because we want to demonstrate how we use VisionX to create backoffice apps in under 5 minutes! The app itself isn't complex and does "nothing special", but the same mechanism works for complex applications like our Demo ERP system (read our Code once. Run anywhere post).

Our JavaFX mobile project was based on the great work of Gluon and their JavaFXPorts OpenSource project and also on RoboVM.

After one year of JavaFX development, we thought it's time to write about our experience.

We started in Nov. 2014 with our first bigger JavaFX tests. The idea was an UI implementation for JVx. We thought it should be an easy task because JavaFX is a desktop technology. We had another research project in 2012, but the result wasn't as expected. Sometimes it's a good idea to re-start from scratch!

JavaFX wasn't very popular and is still not a Superstar, but we love researching and we thought it might be a good idea to bet on JavaFX. Not only as pure desktop solution and Swing replacement, but also for mobile app development based on JavaFXPorts and for embedded devices, like Raspberry Pi. So we had this big picture in mind.
We thought it would be awesome to create a single JavaFX application, for all platforms and devices. Sure, some other companies tried to solve this problem as well, but we didn't try to do the same. Our idea was simple and based on JVx. We hade this awesome JVx application framework which enabled GUI and technology independent application development. So we tried to solve the GUI problem because all other things like persistence, remote communcation, i18n, ... were already solved by JVx.

We did different GUI implementations for JVx, before we started with JavaFX. Our first one was based on Swing, followed by QTJambi, GWT, GXT, a headless variant and - last but not least - vaadin. We also made some tests with Flex and Pivot, but we didn't create more than some simple PoC. To be clear: GUI technology know-how was not the problem!

We knew that JavaFX didn't have a solution for MDI and especially a DesktopPane was missing, but it wasn't a problem to create custom components/controls. We had some hard months of development because we found out that JavaFX wasn't a mature toolkit like Swing. We had to find many workarounds for very simple problems and had to create more custom components than expected. We solved most problems in our own code, but it wasn't possible to change some basic problems. We tried to get in contact with the developers, via JIRA, but it was hard to explain real-world use-cases to toolkit developers. Our developers at SIB Visions create custom products and projects together with customers for their needs. So we had many UI toolkit requirements from real users. Some issues were accepted but not all. Many bugs were fixed but we had big problems with Feature Requests. So far so good.

We finished our JavaFX UI implementation in April 2015 and it was a big success, because we had a fresh UI technology with lots new features and animations, transitions, web and media views, .... awesome.

We thought that JavaFX will be improved in 2015/2016 and it will be mature enough to use it for our customers.

Wait... what's the problem with JavaFX?

Performance, Memory, limited chances to modify standard controls

The performance is not good, if you have many controls (= nodes). It's different on Windows, Linux, MacOS. It's much better on MacOS than on any other supported OS. If you develop business/backoffice applications, the performance is very important. Sure, if you create simple form based applications, it doesn't really matter.

We use JVx to develop huge backoffice applications and currently, JavaFX should be used with care.

What do we mean with "performance is not good"?

• Large TableViews have scroll delays
• Layouting sometimes need some "extra repaints"
• Scrolling with many controls is not immediate
• Startup time of an application is too long, compared to e.g. Swing applications

The version number of JavaFX 8 is too high for it's maturity.

JavaFX has big potential but we're not sure if it'll survive it's predecessor Swing.

And we're not alone with our opinion: Should Oracle Spring clean JavaFX

But there are also companies with JavaFX applications: JavaFX Real-world apps

There's more

The toolkit issues are one thing. Another big surprise was that Oracle stopped official ARM support in Jan 2015 which didn't mean that JavaFX doesn't run on ARM devices (RaspberryPi, ...), but it's not officially supported and Oracle doesn't fix bugs or implement improvements.
Thanks to Gluon it's still very easy to use JavaFX on ARM devices.

Another step backwards was the migration to Bugzilla. In 2014 (and earlier), JavaFX was a "newcomer" and announced as Swing replacement. The development process at Oracle was very open and you had a "direct connection" to the development team, or something like that. It was very simple to report issues and to get feedback from the developers. It was fantastic to see and feel the progress. This is different nowadays, because the ticketing system moved from JIRA to Bugzilla and it's more or less readonly for standard developers.

One problem with JavaFX is that Oracle doesn't tell us the strategy behind JavaFX. The investment of Oracle in JavaFX was high, but what will be the next step? It's hard to bet on JavaFX without definitive commitment from Oracle.

But we still hope that JavaFX will be the one and only UI toolkit for Java.

JavaFX for Android and iOS

In summer, we moved forward and tried to use JavaFXPorts. It makes it possible to use your JavaFX application as native Android and iOS apps. Our JavaFX UI worked with some smaller changes out-of-the-box. It was awesome to see our JVx on Android or iOS devices! It was a milestone.

But things have changed since summer because JavaFXPorts has a depency on RoboVM. It was an OpenSource project and was a big win for the community. But now it's a commercial tool (read more). This has no impact for us, but means that we can't offer an out-of-the-box OpenSource solution.

JavaFXPorts also works without RoboVM and there are plans for a JVM running on mobile devices, but this won't solve the problem that you need access to device features/APIs. But we'll see what happens in the next few months.

We had some fun in the last few weeks because we tuned our application frame for mobile devices. A mobile application has some specific characteristics and isn't a 1:1 desktop application. A desktop application usually has a menubar and a toolbar. The same app on a mobile device shouldn't use a menubar or toolbar. It should offer a hamburger button which offers a custom menu. Also the style of the controls should be different on mobile devices, e.g. Tabsets.

There are two interesting projects which offer custom mobile controls. The first is a commercial product, from Gluon and the second one is JFoenix and it's OpenSource (LGPL). We took JFoenix because it met our requirements and JVx is OpenSource.

We have some screenshots in older posts:

• Code once. Run anywhere
• Live CSS hacking

Resume

JavaFX has potential to rule the Java UI world, but it needs an official commitment/statement from Oracle. Now it's unclear if JavaFX is the right UI technology for the future.

We hope that JavaFX is the right toolkit, but we aren't sure. Our investment was risky and high, but no risk - no fun. The results are awesome!

Thanks to JVx the UI technology is not important for us, because if JavaFX won't make the race, we still have Swing or vaadin. It's important to be UI technology independent because it saves time and money and is future save.

Our current Vaadin UI got a new feature. It's now possible to set a background image for a Panel.

This feature was already defined in JVx' IPanel but our vaadin UI didn't support it out-of-the-box.

We already had a custom Panel and it was an easy task to add missing functionality. Sorry, we don't have an extension for this feature, but it shouldn't be a problem to create an extension based on our implementation.

Our solution

As mentioned, we had a custom panel implementation. Its a simple extension of CssPanel with an implementation of SingleComponentContainer. The class can be found here.

The important part in our implementation is that we have a custom State and Connector for our Panel. The state got additional properties for the background, like repeat-x, repeat-y or the size. The image itself is a Resource and we re-used the existing transport mechanism for image resources. The mechanism is available in AbstractClientConnector. The nice thing with this standard mechanism is that the client has a method to build the correct image URL, automatically.

Our implementation:

The most important thing was the connector on client side which reads the State and sets the background image via css. The full class is available here.

The following code snippet shows how we set the background image. It's not really tricky

The method getResourceUrl is an existing method and returns the full image URL. It was easier to re-use this method than creating the URL manually.

We made a simple test in our showcase application and the result was as expected:

Background image

The image was set with following code:

JavaFX mobile

Today is the last conference day and we had our second talk. The title was: Mobile applications with JavaFX We described how a JavaFX desktop application could run on a mobile device without any changes but with mobile user experience. Thanks to JavaFXPorts it was very easy to realize this use-case.

If you have time and want to talk about JavaFX, JVx or VisionX visit our booth and push our buzzers.

SIB Visions @ DOAG

The talk about MS Office as Report designer was on Tuesday:

Reporting design with MS Office

We showed how we use MS Office to create Report templates and fill the templates with data. It's super easy for an end-user to create a custom report becasue MS Office is well known and easy to use. We use this template mechanism for our customers and it's a super easy and fast solution. Lets create a comples Report in minutes without additional coding effort. Simply use MS Office and layout your Report. The fill-in mechanism just uses your template.