We have some great Videos for new VisionX users on our YouTube channel.
Here are the links:
Getting started
How to create your first application
How to use Eclipse & VisionX in real time
Check them out!
These Videos will help new users learning VisionX 
Development | rjahn | 18/09/2018 | 
Comments (0)
I'm happy to announce that our Workflow Engine will work with Oracle Forms.
The current state is beta but we'll release our Workflow engine in the next days. We found some time to test the integration in Oracle Forms and the result is soo cool. It works like a charm.
So it will be possible to embed our Workflow engine in your oracle Forms. It'll be possible for your users to design custom flows and processes. The engine itself is database driven and will work with your Oracle Forms application.
More details will follow in the next days, but here's a first impression:
Workflow Engine - Oracle Forms
It's a standard Oracle Forms window/canvas with our Workflow Designer, embedded as Java Bean.
Feel free to ask your questions
Development, News | rjahn | 11/07/2018 | Comments (0)
We improved the support for standard MacOS LaF in our Swing UI and VisionX. The LaF has a lot of rendering problems. We tried to use another LaF implementation but had other problems. So we decided to keep the standard Java MacOS LaF.
The problems
 Field border problem |
A simple JTextField has a 5 pixel focus border. This is horrible because the focus is about 2 pixel. The other problem is that a JTextArea wrapped in a JScrollPane doesn't have the 5 pixel border. This makes it hard to create nice looking layouts.
We fixed this problem:
 Field border without gap |
Looks better. One problem is that the JScrollPane doesn't paint the focus if the JTextArea has the focus. This is a LaF problem and we didn't find a workaround for this problem.
Standard Java appliacations show the menubar in the same frame
 Application menu |
If you set the system property:
the menu will be placed in the menu bar of MacOS:
 macOS Menu |
We fixed the problem that setting the menu to null will keep the menu as it was.
The height of Standard Comboboxes is wrong:
 Combobox wrong |
We fixed the problem as good as possible:
 Combobox fixed |
The toolbar height was wrong because of layout calculation problems:
 Wrong Toolbar height |
We fixed the problem and the toolbar height is correct:
 Toolbar fixed |
The image gaps in VisionX wizards was not recognized:
 Wrong gaps |
It looks better without gaps:
 No gaps |
If you had a button without an image and a button with an image, the height of the button without image was higher than the button with an image. This is a LaF rendering bug:
 Wrong size and font |
The fonts are also different. We didn't know why there has to be such a difference, but we fixed the problem in Swing UI:
 Button with correct size and font |
All changes are available in our nightly JVx builds
Development, News | rjahn | 09/07/2018 | Comments (0)
This article is a short introduction of our brand-new product. It's a super simple workflow engine. Our workflow engine is database driven and can be configured and extended for your needs. The engine itself contains a simple board which allows you to create workflows. The configuration will be read from and saved into a database. The workflow steps are configured in the database and the engine simply executes the configured steps.
We tried to find a workflow solution for our needs or a simple product which supports drawing workflows. We found a lot of complex workflow engines and tools but not a simple one. We didn't like complex solutions so we started with our own workflow enigne.
And here are some impressions
 Workflow Designer (loop) |
 Workflow Designer |
The left area contains the list of available workflows and all used steps for each workflow. The search option is a full-text search for workflows and contained steps.
The right area contains all available/configured steps. The steps are configured in a database. We offer a simple Java interface which makes it possible to implement your own workflow steps. The area also contains a mini version of the board. This makes it smooth to search through the workflow.
The middle area, the board, contains the workflow designer. It supports Drag and Drop.
The created workflows can be used from any JVx based application. With next VisionX release, it'll be possible to use the new workflow engine.
The workflow engine will be available as AddOn for VisionX and as standalone version for product bundeling.
Development | rjahn | 28/05/2018 | Comments (0)
We're happy to anounce that VisionX 5.1.8 is available!
It's a simple update release of VisionX 5 with smaller bugfixes and one awesome new feature.
The bugs fixed
We didn't save this conditions correctly.
It wasn't possible to use arrow keys for navigation in HTML5 tables.
We had some problems with floating license check with 1 user and the HTML5 live preview.
The new feature
We now create Swagger documentation for application' REST services. It's possible to test your REST services with your browser - super easy.
The download area already contains links to VisionX 5.1 binaries.
Release notes | rjahn | 22/05/2018 | Comments (0)
My fourth year at SIB Visions has ended, once more it is time to take a deep breath, sit down and have a look at everything that has happened so far.
As mentioned in my last years post, there are several new demo applications available in the VisionX application store. These range from member portals to ERP applications and demonstrate not only the capabilities of JVx but also those of VisionX.
The blog posting already outlines quite well what the demo applications encompass, so there is no need here to reiterate that. However, working in these was quite interesting because it is such a vast spectrum of applications, they have quite different requirements and as I've said before (at some point), one should always use the product one does create.
The JVx Reference series, a collection of blog posts which is supposed to give an overview over the most important aspects of the JVx Application Framework, has also grown considerably:
The series now covers all of the most important topics of the JVx framework. The new articles are outlining the remaining core concepts of JVx and give a good overview over these. If you feel like something is still missing and should be added to this list, feel free to drop us a message so that we can include it. We're also considering pressing these into an easier to digest format, to make the entrance of newcomers to JVx as easy as possible.
After having it around for so many years, I've finally managed to properly introduce the JVx Kitchensink last year. It is a simple demo application which is supposed to give a good overview over all the components and controls of JVx.
It is also my go-to application when it comes to debugging problems with JVx or testing the same functionality in different implementations. With this introduction it also received a much needed upgrade in aesthetics and functionality, for example it is now easy to see the source of each sample.
I'm quite a fan of LuaJ, a Lua JITC for Java. It allows you to quickly and easily deploy a complete Lua integration and adding scripting support to your application. I've worked with LuaJ on a private project of mine and have been very fascinated with how easy it is to create a scripting interface with it, so of course I could not withstand the temptation to create a proof-of-concept JVx bindings library with it.
These bindings give you access to the complete GUI layer of JVx, directly from Lua scripts. There is also a demo application for these bindings available.
Additionally, these bindings are used in the JVx FormLayout Visualization application, which makes it easy to inspect certain configurations of the FormLayout and see how it behaves with each change.
In the late summer of 2017 we've started working on migrating from Vaadin 7 to Vaadin 8. That was not a small task, but was eased by the availability of the Vaadin 7 compatibility layer, which allowed us to gradually and deliberately upgrade parts and single components to the new version. All in all, the migration went rather smooth even though it was quite time consuming. On a similar note, we took the opportunity and enabled the new client-side layouts by default. These new layouts provide a much more sophisticated layouting mechanism and allow the applications to utilize layouts as it was previously only possible in desktop applications.
I already wrote briefly about these new layouts in my last years posting, and I will do so again. The main motivation behind these new layouts is to be able to use sophisticated layouts on the client side which are driven dynamically by the size of each component. There is no such support in Vaadin by default, so we had to create our own layouts for this. The main idea behind these layouts is to have the layouting mechanism completely on the client side and that it only operates with hints (constraints) given by the server side, if they are required at all. What is happening on the client side is that each component which is added to the panel is measured and then absolutely positioned inside the panel according to the layout. So technically it works exactly the same as the layouts in the Swing or JavaFX implementation, with the sole difference that the a layer of indirection is between the component management and the layout itself (namely the client/server connection).
While further work was done on these layouts, the need to actually being able to measure the time spent in each panels layout method was also required. Unfortunately, there wasn't a ready made solution at hand so I dug around the Vaadin internals and found that it has a profiler built-in. Nice, or so I thought, as it turned out, getting it to spit out the needed information was a little bit more work than anticipated, however, in the end I was able to gather quite valuable information from it.
The remaining time was filled with making sure that Vaadin 8 worked the same way as Vaadin 7 did, and replacing all the deprecated Vaadin 7 components wherever possible.
As part of our efforts to unify our documentation and provide a better documentation experience (for us, our users and our customers) we've built a custom documentation pipeline. This pipeline allows us to feed it Markdown documents and spits out HTML, PDF and DokuWiki files. The main component which enables us to do that is Pandoc, the swiss-army knife when it comes to converting documents, and wkhtmltopdf, which allows to convert HTML documents into PDFs.
The requirements for this pipeline were simple enough:
That lead us to the decision to use Markdown with Pandoc. Markdown is easy to write and easy to read and does not dictate any sort of styling for the finished document (though it is possible with embedded HTML). Pandoc can convert the Markdown documents to HTML and DokuWiki and additionally allows us to manipulate these documents on the fly by using Lua filters. With these filters one is capable of manipulating the internal document representation and add or remove additional parts or modify already existing ones. In short, there is not much the Lua filters cannot do.
Conversion to PDF was a quite different matter, the logical choice was to convert the HTML to PDF, as this was already quite well laid out. wkhtmltopdf is a tool which uses the Qt Webkit engine to render a HTML document into a PDF, there are quite a few gotchas on the way, but overall it does that very well. Additionally, with the modern CSS variants, one can write rules for different devices, which make it easy to change the style of a document as soon as it is send to a printer.
Last but not least, we needed a way to easily start this pipeline on different machines. We've opted to use Apache Ant as launcher environment for the pipeline for a few simple reasons:
So the only thing that needed to be system dependent were the launcher scripts. We've put all the necessary logic into the Apache Ant build file (which is mostly copying files and executing different programs like Pandoc) which in turn is invoked through the systems specific launchers.
I'm not sure in what detail I can go here, but the most work here was obviously to create the HTML template and figuring out which options make the most sense to use. I can give you two pieces of advice, though. First, when working with Pandoc and Lua filters, the native (or JSON) output format of Pandoc is your best friend when it comes to debugging the document structure. Second, when trying to create print material with wkhtmltopdf, disable the automatic scaling of content, it will save you a lot of headache.
We're still looking into how we can make this pipeline available to the general public, whether it will be as a product or as (partial) FLOSS has not been decided by now.
With the start of the new year we've found the time to squeeze some much needed bug fixes into EPlug and publish the 1.2.7 bug fix release. It brings various bug fixes, improved performance and a better DataBookView to the table.
There were some problems surrounding our PostgreSQL JDBC implementation. As it turned out, when an exception occurs during a transaction, PostgreSQL is awaiting a user interaction on how to proceed. I've outlined everything related to it in another blog post, and as it turned out, PostgreSQL wasn't even the odd one during my tests.
That was a quite slow year, actually. The Vaadin 8 migration took a lot of time, but a few interesting projects sneaked in none the less. I'm currently working on another quite interesting project which I hope will be finished within the next time. Stay tuned for it.
Thanks to everyone at SIB Visions, it's been an awesome year and I'm looking forward to another one with all of you!
Information | rzenz | 07/05/2018 | Comments (0)
What is Xamarin?
Read all details here.
It's a company and a really cool platform for mobile application development. It enables you to use one codebase for iOS and Android.
Since 2016, it's more or less free for everyone.
We tried Xamarin some years before 2016 and it wasn't free. So it wasn't an option for us. Not because it's using C# as programming language. We already have mobile clients for JVx applications but they don't share the same codebase. There is one client for Android and another one for iOS. The source code is licensed under Apache 2.0.
Our native clients work great but we think they could be better.
In the last days we made some tests with different tools, to create a new universal client with one technology. A HTML5 client wasn't an option for us because of different criterias. A real native client was important during our evaluation.
Some links to different opinions:
We made good first progress with Xamarin and because of its pricing, it was the winner of our evaluation. Sure, Xamarin is C# but it's better to write C# than JavaScript. Another plus was that we already have a simple JVx connection port to .NET based on C#. So we could reuse this code.
Why not JavaFX?
The problem with JavaFX is, that it's unclear what will happen with JavaFX in the future. There are different articles about the future of JavaFX, but the one from Jonathan Giles makes it clear
Sure, there's Gluon and some other individual developers, but the overall performance isn't relly comparable to native apps. It's awesome what happened in the last years, but the progress is missing.
We still have our JavaFX based UI, but we're not sure if JavaFX will survive or it will be commercialized. So it's better to have an option.
Why not CodenameOne?
It's a really cool technology and works great with some smaller performance glitches (simply try the current KitchenSink from the App stores)..
WORA just works!
The cloud build isn't what we prefer and the pricing is not good for our use-case. Our client should be free, open and easy to use for every developer.
Here is a simple test application for REST access to our Heroes application, used in our Angular test application.
 iOS client |
 Android client |
The source code for this test:
namespace TableViewSamples
{
public class RESTTable : ContentPage
{
public RESTTable()
{
GetData();
}
async void GetData()
{
this.Title = "REST Data";
var table = new TableView() { Intent = TableIntent.Data };
var root = new TableRoot();
var section1 = new TableSection() { Title = "First Section" };
var authData = string.Format("{0}:{1}", "user", "pwd");
var authHeaderValue = Convert.ToBase64String(Encoding.UTF8.GetBytes(authData));
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", authHeaderValue);
HttpResponseMessage response = await client.GetAsync("https://...");
if (response.IsSuccessStatusCode)
{
HttpContent content = response.Content;
var result = await content.ReadAsStringAsync();
var parsed = JsonConvert.DeserializeObject<List<HEROES>>(result);
foreach (var record in parsed)
{
System.Diagnostics.Debug.WriteLine("Data: {0}", record);
section1.Add(new TextCell { Text = record.NAME });
}
}
table.Root = root;
root.Add(section1);
Content = table;
}
}
public class HEROES
{
public int ID { get; set; }
public string NAME { get; set; }
}
}
Development | rjahn | 20/04/2018 | Comments (0)
 |
VisionX 5 is available It's an awesome version with so many new features and new possibilities. We had some hard months but now it's done and it's available for everyone. We made the decision to wait a little bit longer with VisionX 5 because of changes in used frameworks. |
The new Version is more web centric than any version before, but it's not a web tool. VisionX 5 still supports Desktop application creation.
So what's new?
All new applications will contain an empty application.css. This file could be used to add custom HTLM5 application styles.
The new CSS editor makes it possible to change the style of the application directly within VisionX. The Editor supports Search/Replace/Goto line. It's also supported to reload the application in the browser. Simply test your style changes immediately.
CSS Editor
It supports syntax highlighting and auto completion. Read more...
Newly created applications will use the new default theme "valo" as standard theme. It's possible to change the theme in web settings wizard.
VisionX 5 is shipped with following themes: Standard, Valo, Valo (small), Mobile
The page navigation is now enabled by default. It support Back/Forward Browser navigation for the application.
It's also possible to enable tabset navigation. This feature enables Back/Forward navigation for tab sheets. This feature is disabled by default. It can be found in the web settings.
It wasn't easy to change the favicon for your application because it is stored in different locations. VisionX 5 solves this problem because it's possible to change the favicon directly in VisionX.
Favicon support
It's also possible to use the favicon as icon for desktop applications. VisionX will extract the image directly from the favicon.
The Menu Button is a simple button which shows a popup menu if you click the button. The component itself also supports a default action, but this is a new feature of JVx' UIPopupMenuButton. The component is available in the elements area.
Menu Button
The web elements is a new element area. The elements are preconfigured components like an Insert Button. This Button simply inserts a new record in a table. This web elements will work for desktop applications as well, but are often used in web applications.
Web Elements
The Table Menu Button is a Menu Button with preconfigured menu items like Delete, Export. It's also possible to add custom menu items via menu customizer.
Table Menu Button Items
It's now possible to configure the web menus independent of the desktop menu. Every screen has a menu icon and a toolbar icon. The menu icon will be used for the menubar and the toolbar icon for the toolbar in Desktop applications.
The HTML5 application has different layout modes. The standard, the corporation and the legacy mode. The standard mode shows the menu in a sidebar on the left or right of the browser frame. This sidebar was used as toolbar in versions before VisionX 5. If you did configure a toolbar image, the screen was shown as image in the toolbar of your Desktop application and in the sidebar of your HTML5 application. It wasn't possible to configure an image, only, for the HTML5 sidebar. This feature is now available in the menu settings wizard.
Web Menubar
The toolbar image will be used for the toolbar in the corporation mode, as usual.
The Edit Panel now supports a Navigation mode: Single click, Double click and No navigation.
Customizer
It's also possible to morp an Edit Panel into a Tabset, a simple Panel or a Group Panel.
It's now possible to show/hide all columns of a table via customizer. It wasn't nice to click through e.g. 50 columns. Now it's easy to show only 2 columns of e.g. 50 columns.
Show/Hide all
It was possible to map desktop images for e.g. HTML5. It's better to use simple/flat images in web applications compared to desktop applications. The web style should be or is different to standard desktops.
With VisionX 5, we did the default mapping for you and a standard web application will show different standard images.
Image mapping
Same application, no changes necessary. Only some image mappings!
JVx has FontAwesome support for a while, but this feature wasn't integrated in VisionX. The new image chooser supports FontAwesome.
FontAwesome
It's now supported to extend VisionX with custom image libraries. We have different commercial AddOns in our Solution store.
Image library AddOns
The libraries will extend the image chooser.
Extended Image chooser
It's also possible to integrate your own offline image libraries.
We have new tutorials and new Tutorial Applications in our Store.
The integrated edit panel has new features like Tab Navigation by Buttons. The edit dialog now has OK and Cancel. It supports single our double click navigation.
Our action editor now supports (Oracle) database function calls and server-side function calls.
Server Actions
The source code editor now supports syntax highlighting and code folding.
Action Code Editor
It's now possible to change the button border behaviour.
Button options
The search field now supports Contains and Starts with.
Search options
We improved the Split Panels and fixed some problems with focus.
HTML5 Styling
The split handle is now small.
Our HTML5 GUI is now based on Vaadin 8.1 instead of Vaadin 7. With Vaadin 8, the UI is faster and supports all modern AddOns from the Vaadin Directory.
We offer a Vaadin AddOn for VisionX to integrate AddOns from the directory.
We rewrote the layout mechanism of our HTML5 UI because our Form Layout didn't support all available features. Now it's possible to overlap elements or to work with Anchors directly. The new layout mechanism can be disabled if necessary. In this case, the old mechanism will be used.
The online documentation is now available.
Documentation
VisionX 5 still contains Applet and Webstart support, but with VisionX 6 we will remove Applet support because the technology is EOL.
The new Version of VisionX will require a new license. Simply ask your sales contact to get a new one. The download area already contains links to VisionX 5 binaries.
Please report any problems as usual and have fun with VisionX 5.
Release notes | rjahn | 07/04/2018 | Comments (0)
The next big update of VisionX will be available by the end of this week.
We have awesome features for you and your applications.
Some impressions:
New Web Elements |
 New Tutorial Apps |
|
More Web Settings |
 FontAwesome Support |
|
New Web Menubar support |
More details will be available in the next days 
News | rjahn | 04/04/2018 | Comments (0)
The support for ANT and JRE6 with Eclipse Oxygen.2 (December 2017).
The plugin was created for:
Don't forget the -clean start (read the original article for more details)!
One more thing you should do:
Oxygen.1 and Oxygen.2 contain ANT 1.10.1. This version requires Java 8. In order to use Java 6, you have to download ANT 1.9.x. Simply download ANT and set the ANT Home to your version, via
If you try to use the bundled ANT with JRE 6, it will fail with an Exception.
Download the plugin from here. It works for us - no warranty!
More Details: Eclipse Oxygen.1 with ANT and JRE6
Development | rjahn | 15/03/2018 | Comments (4)
RSS-Feed