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

Category: Release notes

Demo ERP 1.1, iOS & Android App updates

First, we've released version 1.1 of our Demo ERP application. The full source code is available on SourceForge. It doesn't have more features than 1.0 because it's a simple lib upgrade release with improvements for developers.

The DemoERP.zip now contains the whole project structure and not only the source files. Simply unzip the archive, import the project in your Eclipse IDE and start the DemoERP.launch file (sure, DB must be configured manually). The archive contains small README files with additional information.

We fixed code signing problems and you shouldn't have any problems with DemoERP.war. So, simply deploy the war and open http://localhost/DemoERP/web/ui in your browser (see README).

The release contains our latest vaadinUI based on 7.4.5 and our latest JVx.mobile lib. The mobile lib was needed for our updated mobile apps for iOS and Android.

Yepp, we've new apps in the stores (still native but not based on JavaFX). The apps have a buch of new features like custom view styles (based on style property of JVx), image viewer/editor or the new Form view. But the biggest improvement was offline support. It's now possible to switch to offline mode and back to online mode. Sure, we sync your offline data!

It's an awesome feature because it's a generic solution and you don't have to change anything in your application. It simply works!

Both applications have the same features but system specific.
Here's the iOS link.
The Android app via Google Play.

Both apps work great with latest VisionX releases and simply use it to test your VisionX application - LIVE - without redeployments - on your mobile devices!

JVx' JavaFX UI - first release

We're happy to announce our first beta release of JVx' JavaFX UI with version number 0.9 :)

The release is two weeks later than planned but we had some extra tasks to do. We didn't set 1.0 as version number because we have some open tickets which are important, in our opinion, for 1.0. The 0.9 beta is already feature complete with some known bugs.

We also released an extra library: JFXtensions
It contains all standalone controls and extensions which are independent of JVx. The MDI system, our layouts, styled scene and much more.

Here are the download links:

All libraries are available on maven central as well.

We've released DnDTabPane as external lib on maven central, because it wasn't available and our UI needs the dependency. The DnDTabPane is licensed under EPL 1.0 and JVxFX UI, JFXtensions are Apache 2.0 licensed.

The DnDTabPane is still based on Tom Schindls implementation for Efxclipse.

We've a very cool video of our work during the last 4 months. It's the visualizaton of our dev repository:

Respository visualization


The visualization was created with Gource.

Developer Information

The dev2015 branch was merged back to trunk. If you're working with our branch, please switch to trunk.

VisionX update release 2.2.135

The current update release of VisionX 2.2.135 is available for our customers or as trial. It's a smaller update release with two important new features:

  • Vaadin 7.4.2

    We've bundled vaadin 7.4 with our application and you can use all available features of vaadin 7.4. We currently don't use new Grid component of vaadin 7.4 because it's not implemented in our vaadin UI. We'll replace the Table with Grid as soon as possible.

  • Corporation view

    This awesome view is now available out-of-the-box. Simply enable the design via web application settings screen.

The rest are fixes for smaller bugs:

  • Support for username/password in Oracle JDBC Url
  • protected access instead of public, for DBAccess
  • Support all web setting in live preview (corporation design, navigation, mobile)
  • Support for loading resources form public content area
  • Don't delete unknown events from source file
  • Designer update for better free-form layouts

Have fun with VisionX 2.2.135.

JVx 2.2

Today is a great day because I'm very happy to announce JVx - version 2.2.
It's an awesome release with soo many new features.

First of all, the LoC analysis. Here are some very interesting numbers for you:

JVx library   Swing UI
LoC   Type
73.759   Code
62.025   Comments (~ 46% of Code)
19.662   Empty lines
155.446   Total
LoC   Type
34.032   Code
18.882   Comments (~ 36% of Code)
7.662   Empty lines
60.576   Total
 
JVx library (Test cases)  
LoC   Type
21.093   Code
11.441   Comments (~ 35% of Code)
7.300   Empty lines
39.834   Total

Not bad if you compare it with other releases: 0.8, 1.0, 2.0.
We've still a very small codebase, compared to the features. The code quality and test coverage are still "green".

Some additional numbers:

Files and Tests
JVx library source files   594
Swing UI source files   135
Test source files   140
Total   869
Still a small codebase ;) and still very easy to maintain. Here are more numbers, about testing:
 
Unit tests (no UI, without manual perf. tests)   958
Class coverage (without UI)   81%
Method coverage (without UI)   69%
Our coverage got better since 2.0 - well done.

TOP 10 classes

Classname   LoC
MemDataBook 4.028
DBAccess 3.772
JVxTable 2.510
ArrayUtil 2.224
StringUtil 1.738
Server 1.715
DBStorage 1.542
JVxFormLayout 1.243
FileUtil 1.182
SwingApplet 1.102

Sure, MemDataBook and DBAccess are our main classes but we should check if it'll be possible to reduce complexity!

And last but not least, a short overview of new features:

  • Performance tuning
    JVx got a boost. We pimped our model to be super fast. Sure, it was fast and we didn't have any problems... but during some code reviews, we found some lacks because of gc calls. The memory consumption wasn't perfect and not gc friendly. We created a lot of temporary String[] and event objects, even if the weren't needed.

    Long story, short: Inserting 2.000.000 records with 16 columns was done in about 23 seconds. Now: 1.5 seconds.

  • Support for IoT/M2M/Microservices

    We pimped our remote communication a little bit. It's now possible to embedd JVx, especially the server class, in any environment that supports Java. We had an implementation for Java application serves like Tomcat or Wildfly, but no solution for plain socket servers. We put a lot of work in this part of JVx. We now have out-of-the-box solutions for vert.x or plain socket servers. It've never been easier to write remote applications with JVx.

  • Better JNDI support

    We had JNDI support since JVx 1, but now it's bulletproof. Use JNDI to configure your database connection or the whole application. It's possible to load application config.xml via JNDI. Same is valid for server configuration. We allow, so called, virtual configurations.

  • @PostConstruct and @PreDestroy

    We've support for both annotations in our server-side Lifecycle objects. It's now possible to remove your workarounds like:

    if (getClass() == Application.class)

    to find out whether the application LCO or session LCO was created. The session LCO extends the application LCO and otherwise it wasn't possible to do things only if application LCO was created, because constructor was called for every session LCO again.

  • Lambda support

    It's soo much fun, working with lambdas and Java 8. We're happy to have full support for lambda expressions in JVx especially for event listener handling. And it's backwards compatible (Java 6, 7) without restrictions.
    Be sure that you recompile your JVx projects with JVx 2.2 library.

  • Log4j support

    We love using built-in Java APIs like Logging API - because it doesn't need extra libraries. But we're open for 3rd party libraries and log4j(2) is too popular to ignore it. So we have official support for it in JVx. Simply use the new log factory com.sibvisions.util.log.log4j.Log4jLoggerFactory for your application and configure your loggers via log4j.properties or log4j2.xml.

  • Spring security

    We had a customer request for supporting SAML 2.0 authentication. SAML what?
    Yes, we had the same question, but found that Spring framework had a solution for it: Spring Security SAML. We didn't reinvent the wheel and connected Spring security with our security mechanism. Here's the source code.

  • HanaDBAccess

    HANA is the in-memory db solution of SAP. We've a connector for it. But be careful, because we weren't allowed to tune the database :)

  • Bugfixes

The list isn't complete but contains some important features. The full changelog is available here.

VisionX 2.2 Preview Release

The first preview release of VisionX 2.2 is available. The exact version number is 2.2.41.

It available as trial version or for our customers via download area.

The preview release contains updates of all dependent frameworks like JVx and vaadin UI.

Here's a list with more details:

  • Responsive web applications

    Window shutter web control

  • Browser navigation
  • Application styles
  • Support for embedded devices
  • Style definition with VisionX
    Style definition

    Style definition

  • New EPlug support
  • Custom Database connection strings (e.g. Oracle TNS entry)
    Custom DB URL

    Custom connection string

  • Live Template support for work-screens
  • XLSX reports instead of XLS
  • Ready for application monitoring
  • UI improvements
  • Ready for native Android client

Sure, we fixed some bugs and we also improved overall performance because of improvements in JVx. The most interesting thing is the support for embedded devices like RaspberryPi.

Have fun with VisionX :)

VisionX 2.1 is out

It's done. We proudly present an awesome VisionX release. It has the version number 2.1.905 and has doubled its features.

Here are some of them:

  • Undo & Redo

    It's now possible to Undo and Redo Actions and Reports. Simply add an action to a button undo the creation if you want. The action will be removed from the screen. It's also possible to add the action again, via redo.

    In VisionX 2.0, only UI elements could be deleted but not actions or reports.

  • Eclipse integration

    It's a developer feature and allows bidirectional communication between Eclipse IDE and VisionX. Simply select an editor in VisionX and the source code in Eclipse will be selected. The integration allows faster development because you jump exactly to the source file and code line of your screen. Don't was time for searching properties and files. More...

  • Layout Assistant
    Designer

    The Layout assistant (designer) of VisionX 2.0 was column oriented and it wasn't possible to create free-form layouts without fixed positioning. The new layout assistant still is column oriented but you can use it free-form. You have all features of a layout manager (preferred size, automatic size calculation) but it's easy to create individual layouts which are not column oriented.
  • ActionEditor

    It's a small feature, but the action editor now allows Finish without explicite validating the action. It save so many unnecessary klicks.

  • PDF Reporting

    We have built-in support for toPDF in VisionX. With VisionX it's possible to create PDF reports as Document and Spreadsheet with Word and Excel. Create your report templates with Word or Excel and create PDF reports out-of-the-box. More...

  • Mobile and Web
    Settings

    VisionX got wizards for mobile und web settings. They allow styling of web and mobile applications like background color, background images, ...
    Simply define which image should be used in web or mobile applications instead of the original image, e.g. the mobile application should use flat images but the
    desktop shouldn't.
  • Developer features

    It's now possible to set the name/ID of components. This feature is a developer feature and useful for automated GUI tests or styling via CSS. More...

  • License options

    We offer subscription based VisionX usage. You can use and pay on a monthly base. We don't offer SaaS. VisionX will run in your environment.

    Also new is the support for SAP' Hana. If you work with Hana, you could use VisionX to create Hana based applications.

  • Popup menu

    It's very easy to create custom popup menus for a component. Simply use the new customizer and define the action.
    More...

  • Manual dropdown-list configuration

    We allow the creation of custom dropdown lists directly with VisionX. Create your own statements or storages and use the data wizard to configure the editors. More...

  • Solution store

    The solution store offers ready-made solutions. We offer free and demo applications for learning purposes and also commercial solutions. The solution store is also available for your environment. You can install the store for your intranet, if you need a distribution platform your your applications, addons or modules. More...

  • Responsive application

    Your new web applications will be responsive - out of the box. The styling of the application will be changed dependent of the browser size. We have an API for software developers to create responsive work screens. More...

  • Desktop application

    Create a desktop application per click. Use VisionX to create a desktop application package.

  • Other features

    Repeating frames
    QR Codes

Our customers should check their download area to get access to the new release.

JVx Update 2.1.1

We had some problems with our JVx 2.1 release. It had a bug in server-side processing of BLOB columns because of #987. It was not a problem on client-side, but standard CRUD operations failed.

The other problem was the reopen mechanism of connections. It was an unused feature till 2.1 and wasn't well tested. It worked but not in all circumstances. We refactored the implementation and made tests.

Both fixes are included in JVx 2.1.1.

JVx 2.1 is in da house

Happy birthday :) JVx is 2.1

It's another great release today and ~ 6 month after 2.0. We have soo many cool features for you and of course some bugfixes.
The complete changelog is available on our sourceforge project site.

I want to highlight some features for you

  • Configuration via JNDI or Classpath

    It's now possible to have custom configuration files without our recommended directory structure. We still recommend our structure for multi-application deployments, but it's not important for single deployments or complex enterprise deployments. Find more details about loading strategy in the corresponding ticket #1126.

  • Server-side plugin support

    We introduced IServerPlugin. It allows adding plugins and changing server handling on demand. It's easy to write custom protocol recorder or configure session management via plugin.

  • ServerContext and HttpContext

    We introduced HttpContext and ServerContext. The HttpContext allows live access to servlet request and response (if an application server is in use). It makes no difference if you use REST or standard communication. We set the right instances into the context and your application will work without specific technology checks. We also use HttpContext for JVx.mobile.

    The ServerContext is comparable with SessionContext, but it's earlier in the execution process, because it offers access to sessions directly after creation or detection. It's useful for e.g. plugins.

  • Tab/Focus Index

    We introduced set/getTabIndex in IComponent. This API change allows user-defined component navigation via tabulator or Enter key.

  • CommunicationException details

    It's now possible to find out the connection which throwed a CommunicationException.

  • Alignment for IEditor (API change)

    It's now possible to set the alignment on IEditors instead of the cell editors. Small but very useful API change.

  • Autolink with storages

    It's now possible to create automatic link references with other storage. We had this feature already in 2.0 but only for simple storages without conditions - only from clause was used. Now it's possible to configure custom storages with user-defined sort in the same LCO and set this storages as automatic link reference to other storages in the same LCO.

  • Server side bean processing boost

    We change and improved server side bean handling of our AbstractStorage. Here are some numbers for you:

    ....................... Before | After

    Insert Object[] ... Beans: 200 |   0
    Update Bean ....... Beans: 900 | 200
    Update T .......... Beans: 900 | 400
    Fetch Bean ........ Beans: 600 | 200
    Fetch Object[] .... Beans: 300 |   0
    Update Object[] ... Beans: 500 |   0
    Insert Bean ....... Beans: 400 | 100
    Delete Object[] ... Beans: 300 |   0
    Delete Bean ....... Beans: 600 | 200
    Delete T .......... Beans: 600 | 300
    Insert T .......... Beans: 400 | 200

    Created Beans after processing 100 records.
    The current solution is a performance boost and using Object[] is always faster than everything else.

  • Lazy blob loading

    We don't load Blobs immediate. We load it on request. This doesn't need any actions on client side but be aware of server-side handling because the value of a blob column will be RemoteFileHandle instead of byte[]. You should run your unit tests for your business logic. It's possible to disable lazy fetching, per storage with

    setLazyFetchEnabled(boolean);

    It's also possible to define the threshold for loading immediate or loading lazy. Check

    setLargeObjectLimit
    setDefaultLargeObjectLimit

    of DBAccess.

    This is an awesome new feature because is speeds up data transfer.

  • Custom UI properties

    UIResource got:

    public Object getObject(String pObjectName)
    public Object putObject(String pObjectName, Object pObject)

    It's possible to add custom objects per UI instance, e.g. save custom states.

  • REST services refactored

    We refactored our REST services. The implementation now works without problems and is easier to use becasue we don't need full qualified java names in the URL. We try to find the class via accesscontroller. The accesscontroller got a new method for this.

  • Unique component names

    For all lovers of automated UI tests. We have unique names for all our components. It's easy to create GUI tests with tools like Selenium (web tests) or FEST (swing tests) or whatever you use :)

We have about 107 tickets in this release and it's not possible to explain every change in this blog posting, but be sure - it's great!

The Maven archetype should be available in the next few days, because sonatype archetype listings are not live.

VaadinUI 1.2 released

Our VaadinUI 1.2 is available!
It's a feature release with some bugfixes.

The biggest change was the update to vaadin 7.1.15 and we've already 7.3.3 in our development branch (welcome Valo theme).

What's new?

  • Download extension

    Download dynamic content on-demand or whenever you want via WebSockets. More information and an example project for this extension.

  • Configuration of preserveOnUIRefresh

    Simply use preserveOnRefresh as init-param (true | false) in your web.xml or as URL parameter to preserve the application on browser refresh.

  • Use external CSS

    Use an external CSS file to configure your application style. There's no need to change genereated styles.css for simple tasks. Simply configure the init-param externalCss, e.g.

    <init-param>
      <param-name>externalCss</param-name>
      <param-value>../demoapp.css</param-value>
    </init-param>

    Place the demoapp.css in the root directory of your application (not application server ROOT).

    The css will be placed at the end of the stylesheet links in the generated index.html page.

  • Mobile check

    We check if the UI is running on mobile browsers and set parameters for your application: Web.mobile (= VaadinUI.PROP_MOBILE) and Web.mobile.tablet(only for iPad at the moment) (= VaadinUI.PROP_TABLET). Simply check the parameter in your application.

  • Cache for dynamic images

    If you use images from your classpath, vaadin generates internal URLs for you. This URLs are different per image and the browser cache doesn't work. This handling produces unnecessary requests. We solved the problem with an image cache on server side and custom Image resources. With this changes, the browser cache works as expected.

  • IDs for menu items

    We have an experimental solution for setting IDs on menu items. It's experimental because it's possible that vaadin implements support for that. In that case we won't need our solution anymore. But till then, it works. More information...

  • Responsive support

    It's now possible to register a resize event on the application launcher. Use this event to change your application on-demand. We have some impressions for you.

  • Self-contained packages for Portlets

    We have built-in support for self-contained portlets. It's possible to toggle between global and self-contained mode. Simply set the init-param vaadin.shared (true | false) in your web.xml to use vaadin shared from your application server or the self-contained vaadin.

    General information about self-contained packages.

  • invokeLater and WebSockets

    We've completely changed our invokeLater mechanism because it didn't work in previous versions.

Please check the changelog for a complete list.

VisionX Update 2.0.121

Great news for all VisionX users!

The current update release 2.0.121 is available for download. Please check your download area.

The release is more than just an update release. It contains all currently available features. We wrote about some of them:

Repeating frames
IDE integration
QR Codes
Features for developers
Ready made solutions

It contains current JVx, ProjX libraries and source code.

If you miss some features after upgrading, please contact our product support because previous versions provided features without valid license. If the features are already licensed, no worries.

We have a product and feature overview for you.