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!

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.

It is available from the project page.

What’s different?

We fixed a lot of problems and refactored the code where needed. But we have fantastic new features in this release:

• Server-side MetaData Caching

  The MetaData detection is an expensive operation. It takes a lot of time to detect them and it slows down your UI. We already have a client meta-data cache which reduces remote calls between client and server. This feature was a first perfomance boost but to keep the meta data up-to-date we had to detect them on the server-side continuously. While you develop an application this loss of time is not a problem because you change a lot and need all up-to-date. But after you installed the app in the customers infrastructure, it is unusual that meta data will be changed without deployment. The app should be as fast as possible. Exactly for that use-case we have the new server option:

  <globalmetadatacache>OFF</globalmetadatacache>

  Add this option to your config.xml in your server directory and set the value from OFF to ON (we recommend to set this option with your build system). The performance improvement is unbelievable - try it out

  With this new option, you only loose performance if your Views or database access are slow.

• Automatic link editor visibility

  We set all automatic link editors invisible if the same columns are used in a MasterReference. If you want them visible, use the following method of your RemoteDataBook instance:

  setAutoLinkInvisibleForMasterReferences(boolean);

  The editors are useful if you want to move a detail row to another master row. Thats not the default case and we think they are not very important.

• Save an UIImage

  We changed our IImage interface from:

  saveAs(String pPath)

  to

  saveAs(OutputStream pOut, ImageType pType)

  The old API tried to forward image data directly to files, but that was a bad design for Applets because unsigned applets have no access to files (not true for JNLP services). Now it is possible to save images of your whole application or single components by calling:

  comp.capture(size).saveAs(stream, type);
• Configuration changes

  When you create a new MasterConnection, the server reads your config.xml and caches the settings for the whole session. The session does not update its cache, but it is still possible to change the file in your filesystem! When you close your connection and open it again, you will get the new configuration! You do not have to restart the whole application or the context of your application server.

• Advanced exceptions

  Some client operations calls more than one server object e.g. if you call saveAllDataBooks() of a Data source. If one of your data books throws an exception, you don't know which one, because the exception does not know the name of your member. It is possible to throw specific exceptions which contains the configured remote-name or other information, but what if you forget to do this?

  Now the remote server adds an extra line to your stack trace:

  at com.sibvisions.util.Reflective.call(Reflective.java:277)
  at com.sibvisions.app.Session.<dataSources>.insert(Unknown Source)
  at com.sibvisions.rad.server.DefaultObjectProvider.invoke(DefaultObjectProvider...)

  After the Object Provider invokes the configured object, you find out which life-cycle object (com.sibvisions.app.Session), which object (dataSources) and which method (insert) throwed the exception.
  Now your debug nightmares are gone!

Check the Changelog for a complete list, and use the forum to talk to us

The last beta of JVx 0.9 will be available on Friday. We have some really cool improvements in it. I think the most impressive one is the performance improvement up to 60% for meta data handling. The meta data detection takes a lot of time because of the database access, but with the new (dynamic) meta data cache mechanism this delay is gone!

Together with the 0.9 beta-4, we release the first beta of JVx WebUI 0.8. It is significantly faster and supports a lot of new properties defined by the UI.

We have invested much time and energy and look forward to the publication