We have a cool new JVx feature for all developers! It has always bothered us that the Link Cell Editors are not visible in the tables. You don't see the difference between date/text/number and link cell editors. Now you see the difference!

I hope you find the difference in the following screenshot

Link Cell Editor mark

The new feature is available with JVx 1.0 beta 3 or in our source repository.

It is available from the project page.

What’s different?

This beta release contains important bugfixes for database access and brings some useful utility methods. It was a lot more work as expected, to solve the problems, but now we are very happy with it. Beta-2 is a smaller update, compared to beta-1 but we are already working on beta-3.

And of course we are also working under high pressure on VisionX. The tool is so amazing. Application development of the next generation. We have some really cool videos for you on our YouTube channel. Feedback is always welcome.

Check the Changelog for a complete list, and use our Forum to talk with us

It is available from the project page.

What’s different?

The current version is our first release on the way to 1.0. It contains not a lot of new features and most of them are in the backend. We had a lot of work with some Problems with our DataBook in DataSource Writeback Isolation Level and with Multi Threading. But we are very satisfied with the release!

• DataSource Isolation level

  Compared to the DataRow Level, a DataBook does not save immediate. The mix of databooks with DataRow and DataSource Level with different master references caused problems. Now it is not a problem to use different levels. It is great to use 1:n, n:m or even 1:1 relations with DataSource level, but call save when needed!

• LifeCycle Objects

  If your LifeCycle objects extends from GenericBean, the destroy() method is now invoked after the connection is closed. If you don't extend from GenericBean, you can use the ILifeCycleObject and implement destroy(). It is now possible to close connections to remote systems or execute cleanup tasks. Note that DBAccess automatically closes the database connection.

• Conditions

  The Conditions LikeReverse and LikeReverseIgnoreCase are new and work as follows:

  Like: column-value like user-value
  LikeReverse: user-value like column-value

• Access control

  It is now possible to use a custom IAccessController for your DBSecurityManager. Simply set the full qualified class name in your config.xml:

  <application>
    <securitymanager>
      <accesscontroller>com.sibvisions...</accesscontroller<
  ...
• Security Managers

  Security Managers have now a release method. This is important if you want to change the security manager because now it is possible to free all used resources.

• Cell formatting

  It is now possible to configure images for rendered cells. Image and Text combinations in cells are now supported.

• Utilities

  We added some useful methods to ResourceUtil, FileUtil, StringUtil and ArrayUtil. Introduced the new class TriggerAPI for server-side triggers.

• Changes to 0.x
  • XmlNode.getValue() for an attribute with an empty value returns now null instead of an empty string.
  • UIImage.getImage("invalid") returns null instead of an UIImage instance without content. Be aware of NullPointer Exceptions.
  • logout method of ISecurityManager is only called for MasterSession and not for SubSession. Before 1.0 is was called for all Sessions.
  • estimatedRowCount of IStorage was renamed to getEstimatedRowCount
  • ResourceUtil searches local files only from directories which contains jar files and not for directories which contains class files. Now logging.properties per project are supported.

Check the Changelog for a complete list, and use our Forum to talk with us

We work with high pressure on VisionX. Therefore it became also somewhat calmer. But now it is time to give you a short preview of VisionX.

You don't know what VisionX is?

This tool places all well-known tools into the shade. With VisionX, you create Enterprise Applications without any IT knowledge. Use an incomparable Visual Designer (real 2-way design) to create your application. Create your data model on the fly. No need for deployments. The source code is very clean and structured - not the usual generator spaghetti code. And the best... Change your application while you work with it.

In the next weeks we publish some videos about VisionX and the impressive features. Today we show you some screenshots and hope you enjoy it.

VisionX		New Screen
Started application		UI Design
Capture

VisionX is not an IDE or just for top-class developers. It is for end users and sure, developers will love it. VisionX runs in your Web Browser and the created applications are pure JVx applications therefore created with open source software.

And that's just the beginning!

The UI framework Pivot offers modern UI controls and renders very clean and fast. It has very powerful features and we made a very simple load-on-demand TableView implementation. We used our JVx model, especially IDataBook, for the integration.

The result is a table that loads the data from a database (scroll down to see what happens). The database table contains about 170,000 lines.

Click to start the application

We found a nice article about a simple CRUD application, created with JSP/Spring/Hibernate - read more....

This example is great for a comparison with JVx, because JVx is perfect for CRUD applications.

We used our existing app JVxFirstApp as reference because it is comparable to the Spring app. Our app has some extra features like authentication and a specific security manager, but that does not change anything.
Both applications provide CRUD operations on a table called CONTACTS. A big difference is the used technology: Web (JSP) vs. Desktop (Swing), but it is no extra coding effort to start our app as Web application - with our WebUI.

Why the comparison?

A big advantage of JVx is to simplify application development specifically of database applications. We want to show the difference in complexity and compare some statistics.
Let's start with the statistics:

We used the same code formatter for both projects, therefore the Lines of code should be meaningful. The config files do not contain a lot of empty lines and the jsp files are standard html. We counted every line.

As you can see there is a big difference. Less lines of code do not automatically mean less complexity, but in this concrete example is it so. If your application has few lines of code, it is easier to understand how things work together and it is easier to maintain your application. And if you are a beginner it is better to get fast results without losing the control. That is the case if your project contains many files.

And if you are not a beginner it is important that you have the best flexibility with your framework. Both technologies allow the unrestricted use of other frameworks. But more dependencies means more problems if you plan to update to newer versions. The testing effort should not be underestimated. Fewer dependencies are an advantage!

What is your opinion?

We proudly present JVx 0.9!

This release of JVx contains about 190 changes

Originally we wanted to move some features to 1.0 because they needed a considerable amount of time, but we kept them for 0.9 because each feature is great and saves a lot of work... And now, some months after JVx 0.8 we have a very powerful JVx with tons of new features, performance improvements and still very simple and small. We don't know a framework with approximately the same features as JVx which is about 900Kb. If someone knows a framework, please let us know!

And before we continue with some new features, many thanks to all the database vendors We had a lot of work with different Standard interpretations (quoting, case sensitive, OS differences, imcomplete JDBC implementations, ... )

What's new? ...too much to describe everything in one post, but let's start:

• Database
  • Manual quoting via DBStorage, if you need specific database features and don't change the database
  • Automatic quoting via DBStorage, if you plan to change your database or if you use a storage for different databases
  • Change your database(s) without changing you client code read more...
  • Use existing java.sql.Connection instances to create DBAccess instances
  • PK, FK, UK detection with or without JDBC driver, when needed (DBAccess dependent)
• Server
  
  • Introduced DBCredentials and DataSourceHandler to change DB connections without changing source code read more...
  • Default storage implementation for automatic caching (AbstractCachedStorage)
  • Default storage implementation for memory data (AbstractMemStorage)
  • Server side triggers and POJO support for storages read more...
  • Use custom SessionManager and ObjectProvider implementations
  • Global meta-data caching read more...
  • Better Exception handling for debugging
• User Interface
  • Simple charting
  • Default layouts for Container
  • Save UIImages
  • Changed automatic (master/detail) link editor visibility
  • Introduced TreePathFinder
  • login/logout event handler for applications
  • Modern Message layout
  • Border on/off option for TextFields
  • Translation for Cell Editors (e.g. Date/Time Picker)
• Utilities
  • Added FileUtil.replace, FileUtil.zip, FileUtil.unzip, FileUtil.copy (directories and files), FileUtil.move, FileUtil.delete (directories and files)
  • Added StringUtil.getCharacterType, StringUtil.getCaseSensitiveType, StringUtil.replace (faster than String.replace)
  • Added <XmlNode>.toString(boolean), <XmlNode>.getXmlValue, <XmlNode>.indexOf (deep search)
  • Added CommonUtil.getFirstCause, CommonUtil.equals (supports null comparison)
  • Added ResourceUtil.getResource and ResourceUtil now supports different ClassLoaders
  • Added simple namespace support for XmlWorker
  • XmlWorker has a new option for writing line-feeds between tags
  • Added <FileSearch>.searchFirstFile and support for file/directory pattern search

The above list contains only some cool changes. You find the complete list in the Changelog.

But that was not all.... We added some new features to our WebUI and released the second beta, which is fully compatible with JVx 0.9.

Our Showcase application is up-to-date and uses JVx 0.9 and WebUI 0.8 beta-2.

And last but not least, we look forward to your feedback!

The next Release of JVx has the version number 0.9 and will be published on 1st April.

This version is a big milestone for us because it contains all features which were planned for version 1.0, when we started the development of JVx. In the last two years, some requirements have changed, we got a lot of feedback and therefore we changed our initial feature list.

We are very happy with the quality of the last beta releases of 0.9.

The release 0.9 contains a lot of new features and database operations are significant faster than before. We made a lot of UI optimizations and fixed some design issues. Our persistence API is prepared for case sensitive databases and your UI is not affected from case sensitive changes! With server-side triggers (not DB triggers) it is very easy to move business logic from your client or database tier to your server tier - perfect separation of layers!

In the last days we talked a lot about JVx's DB independency, because every DB has its own peculiarities.
Specifically the case sensitive is everywhere handled different. An Oracle DB prefers upper case column names, table names, ... A PostgreSql DB prefers lower case. It is possible to use quoting with JVx and everything works fine until you switch your database.

Example

We develop an application with an Oracle DB. We don't use quoting because we know everything is upper case. Our client code contains column acces like that:

Now we have to switch from Oracle to PostgreSql (company decission). Because PostgreSQL prefers lower case column names, table names - we get a problem with our client because the column access is upper case. We could create our database objects in upper case and enable quoting for our DBAccess but that is all a lot of work and maybe our existing PostgreSql DB has objects which are case sensitive. We won't change our existing database objects!

It is an option that you change your application code when you change your database, but that is not a real solution - isnt it?

Because we think, things sould be easier with JVx, we decided to change the column access. With the final release of JVx 0.9 you have to access all columns with upper case letters. The mapping is handled from JVx. Because of this change, a JVx application (>= 0.9) will be DB independent.

What does this mean for JVx applications (< 0.9) ?

You need to change all column access to upper case letters where the access is not with upper case letters. That means, you need to check your client code and your server-side triggers.

Backwards compatibility?

It is possible to make it backwards compatible but it is very important to keep JVx simple and one of our first decissions was, that we don't put a lot effort into backwards compatibility before JVx 1.0. Things change after JVx 1.0

Download the new version from the project page.
Our showcase is up to date and all features are available. Login as admin (password.equals(username)).

Some impressions

• Mandatory/readonly coloring

  The WebUI shows mandatory and readonly fields with different background colors, in Editors:

  WebUI 0.7

  WebUI 0.8 beta-1

  and Tables:
  

  WebUI 0.7

  WebUI 0.8 beta-1

• A modest mask

  With WebUI 0.7 we had this big loading bar, centered over the whole application. That was not very stylish. Now we have a small reload image.

  WebUI 0.7

  WebUI 0.8 beta-1

• Show file handles (external content)

  With the Swing UI it is possible to open files and URLs. Now this is possible with WebUI:

  WebUI FileHandle

Check the Changelog for a complete list.