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

New VisionX Demo application is available

Our VisionX solution store got a new demo application. It's a demo for calculated columns. A calculated column is a virtual column, filled with custom content.

Simply install the application from our solution store:

Demo application - Solution store

Demo application - Solution store

The application has 3 workscreens. One demonstrates client-side calculated columns, the second one server-side calculated columns and the third screen demonstrates calculated columns directly in the database. You have different options to use calculated columns, simply check what you prefer.

DOAG 2018 - I'm a speaker

I'm a Speaker I'm a speaker at DOAG 2018 in Nuremberg. It's the 5th year in a row :)

My German talk will be about

Approval process as a web and native mobile app

The talk is a practice report about using a Low Code Development Platform to create a Workflow for Web and (Web/native) Mobile apps.

JVx' REST interface Update for JVx 2.8

Our generic REST interface in JVx is well documented and different examples for different technologies are available. The generic approach itself is smart but not super specific because the implementation follows the CoC paradigm. It's awesome for "REST out-of-the-box" without additional coding effort, but the flexibility is sometimes missing.

We tried to break some of this restrictions and get more flexibility. Here is a list of new features to explain some details:

  • Fetch on demand

    The old implementation always returned all records from the database. It wasn't possible to implement paging or lazy loading. To solve this problem, we introduced new request parameters:

    _firstRow
    _maxRows

    With _firstRow (starts from 0) you define the start record number. The _maxRows defines the amount of records for the resultset, e.g. start from 0 and return max. 20 records, start from 20 and return 20 records

  • Configure visible columns

    The old implementation returned the same column list for the REST call and the GUI/frontend. But sometimes the REST call should return a different list of columns because some internal columns aren't relevant or should be hidden. The new implementation got a new property in the metadata object: visibleColumnNames. If you set this property, the REST interface will return only the configure columns. The GUI won't recognize the new property because GUI controls have own visible column properties.

  • Actions with Array parameters

    The old implementation didn't support simple Arrays like BigDecimal[] as parameter types for action calls. Only List was supported. The new implementation supports Arrays but it's not possible to mix Array and List parameters. An example:

    //valid
    public String createPerson(String[] name, String[] title)
    //valid
    public String createPerson(List<String> name, List<String> title)
    //invalid
    public String createPerson(String[] name, List<String> title)
  • New admin zone

    We introduced a new admin zone for generic admin options. The URLs are:

    http://.../services/rest/APPLICATION_NAME/_admin/ACTION_NAME
    http://.../services/rest/APPLICATION_NAME/_admin/ACTION_NAME/ACTION_PARAM

    Currently, we support following actions (POST requests): changePassword, testAuthentication

    The request needs a JSON object with username, oldpassword, newpassword or password properties.

  • Configurable zones

    We now allow custom zones. The current default zones are:

    http://.../services/rest/APPLICATION_NAME/_admin/...
    http://.../services/rest/APPLICATION_NAME/LIFECYCLE_CLASS/data/OBJECT_NAME/...
    http://.../services/rest/APPLICATION_NAME/LIFECYCLE_CLASS/action/ACTION_NAME/...
    http://.../services/rest/APPLICATION_NAME/LIFECYCLE_CLASS/object/OBJECT_NAME/...

    The zone names are: _admin, data, action, object
    It's possible to set custom names with following parameters in the deployment descriptor: zone.admin, zone.data, zone.action, zone.object

  • Hide object names

    If you want to hide the object name(s), e.g.

    https://.../demoerp/services/rest/DemoERP/Customers/data/customer/

    The URL contains the Lifecycle Name (Customers) and the object name (customer). Both are easy to understand. In this example, we return the customer list from our customers object. If you want to use different names, it's possible to change the name in the lifecycle object code, e.g.

    @Replacement(name="business")
    public class Customers extends Session
    {
        @Replacement(name="clist")
        public IStorage getCustomer()
        {
            ...
        }
    }

    With above code, it'll be possible to request:

    https://.../demoerp/services/rest/DemoERP/business/data/clist/

The updated implementation is still a generic solution but it's now more flexible than before and should help you to offer new services. To use the new features, simply use our nightly JVx builds.

Eclipse Photon with ANT and JRE6

The support for ANT and JRE6 with Eclipse Photon.

The plugin was created for:

Version: Photon Release (4.8.0)
Build id: 20180619-1200

Don't forget the -clean start (read the original article for more details)!

One more thing you should do:

Photon includes ANT > 1.10. 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

(Window >>) Preferences >> ANT >> Runtime >> Ant Home...

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.2 with ANT and JRE6.

VisionX intro Videos

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 ;-)

Workflow Engine for Oracle Forms

I'm happy to announce that our Workflow Engine will work with Oracle Forms.

The current state is beta bu 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

Workflow Engine - Oracle Forms

It's a standard Oracle Forms window/canvars with our Workflow Designer, embedded as Java Bean.

Feel free to ask your questions ;-)

MacOS Swing Look and Feel

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

  • The InternalFrame border problem
  • The field border problem
    Field border problem

    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

    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.

  • Application Menubar

    Standard Java appliacations show the menubar in the same frame

    Application menu

    Application menu

    If you set the system property:

    System.setProperty("apple.laf.useScreenMenuBar", "true");
  • the menu will be placed in the menu bar of MacOS:

    macOS Menu

    macOS Menu

    We fixed the problem that setting the menu to null will keep the menu as it was.

  • Comboboxes

    The height of Standard Comboboxes is wrong:

    Combobox wrong

    Combobox wrong

    We fixed the problem as good as possible:

    Combobox fixed

    Combobox fixed

  • VisionX Toolbar height

    The toolbar height was wrong because of layout calculation problems:

    Wrong Toolbar height

    Wrong Toolbar height

    We fixed the problem and the toolbar height is correct:

    Toolbar fixed

    Toolbar fixed

  • VisionX Wizard gaps

    The image gaps in VisionX wizards was not recognized:

    Wrong gaps

    Wrong gaps

    It looks better without gaps:

    No gaps

    No gaps

  • Wrong button rendering

    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

    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

    Button with correct size and font

All changes are available in our nightly JVx builds

Our brand-new WorkFlow engine

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 (loop)

Workflow Designer

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.

VisionX 5 update Release

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

  • Support for STARTS_WITH and CONTAINS Filter conditions

    We didn't save this conditions correctly.

  • Keyboard Navigation in HTML5 UI

    It wasn't possible to use arrow keys for navigation in HTML5 tables.

  • Floating License

    We had some problems with floating license check with 1 user and the HTML5 live preview.

The new feature

  • Swagger UI support

    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.

Four years SIB Visions, a look back and ahead

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.

Demos

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 layout of a simple screen with a table and a few editors.

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.

JVx Reference series

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.

Kitchensink

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.

JVx Kitchensink - Databinding

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.

JVx and Lua

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.

JVx Lua Demo Application

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.

JVx FormLayout Visualization Application

Vaadin 8

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.

Documentation pipeline

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:

  1. Documentation must be easy to write.
  2. Documentation must have a unified look, always.
  3. Conversion into multiple formats are required (HTML, PDF and DokuWiki).

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:

  • We are already familiar with it.
  • It allows to write complex logic using the ant-contrib tasks.
  • As it is a Java solution, we can write the script once and run it everywhere. So we don't need to duplicate logic over multiple files for different systems.

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.

EPlug

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.

Diving into database specific behavior

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.

The look ahead

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!