From Java Swing to JavaFX - ...to RISC-HTML

CaptainCasa Enterprise Client is a rich client framework for enterprise applications.

Founded in 2007 we were quite exotic ones, having chosen Java Swing as UI technology those days. The main reason for NOT having chosen HTML was: our framework users develop operationally used business applications with long lasting life cycles - and they do not want to afford a rewrite of their UI every 5 years - as it was (and still is) common in HTML environment.

Somewhere around 2011 when JavaFX 2.0 came up, we added a JavaFX implementation of our client. Luckily our rich client framework is following the architecture of "server side interaction processing", so our UI-client is a generic rendering engine, rendering XML forms coming from the server side. Still we explained people, that JavaFX is an adequate technology for the type of  "heavy" business applications they develop - and still the core argument was: independence from "browser volatility" and from browser compatibility issues.

And then, all of the sudden, we were hit by some new idea, how to deal with HTML and browsers so that we can overcome the typical problems that are associated with browser based frontends. We called the idea "RISC-HTML" - and managed to rewrite our complete Java Swing / JavaFX client so that is is running now in a 100% HTML way.

The idea behind RISC-HTML is: we asked ourselves "Which are the basic elements, that a UI technology must provide in order to build some UI framework on top?". The result is: if a UI technology supports "rectangular areas" and "input fields", and if it supports just the ability to absolutely position these elements - then this is sufficient to build up all the business controls that we internally use.

So we did not think the traditional way: "How can we set a framework layer on top of HTML, in order to simplify HTML and to equalize browser incompatibilites?" - because with this approach you are always bound to the known HTML limits. - We went the other way: "How do we build a UI framework on top of primitive elements?" and then checked how to transfer this thinking to HTML.

The result is something which - from the beginning of development work on - pushed and pushes our adrenaline level! It's the first time that we are working within the Browser/Javascript environment, without suffering from it! Just the opposite: we see, that our expectations are fulfilled:

1. no issues with browser compatibility anymore - because of using only two types of elements and because of having encapsulated them inside some "Microkernel" JavaScript library.
2. no problems with any layouting strategy anymore - layouting is done via JavaScript controls on top of the "Microkernel". The browser's role is to "execute the rendering", i.e. to draw rectangles at the right position. The decision, where and why to draw the rectangles is in the hands of the corresponding (JavaScript) control
3. and the most exciting experience for us: RISC-HTML is ...fast!!! Well, this mirrors the increase of speed of browser processing in general - and the increase of JIT-compilation-quality within the JavaScript interpreters.

These ones of you who remember the CISC/RISC processor discussion of  the 90s will clearly see the analogies: the idea of RISC processors is to let the processor only do the core tasks and to arrange the logic "in front of the processor". - It's the same what we do with browsers: we reduce the browser's role to basic rendering processing - and push the logic out of the browser into some program/JavaScript control layer.

Result: RISC-HTML is clearly the future of our rich client framework! It's the combination out of "zero installation" for the end user and at the same time "zero maintenance" on the developers' side. Well, the word "zero" is maybe a bit too aggressive... - but it's fair to say that maintenance effort is drastically decreased.

Check out the information at http://www.CaptainCasa.org and test drive the RISC-HTML based demo environment: http://captaincasa.org/online-demo-server

XI. CaptainCasa Community Meeting

CaptainCasa is a community of European ISVs defining and using a Java based User Interface for significant parts of their applications. The rich client framework "CaptainCasa Enterprise Client" is the output of this community - and available both in unrestricted free and commercial licenses. The framework was transferred from Java-Swing to JavaFX in the recent years.

The XI. Community Meeting is scheduled for Dec 03rd 2015. The meeting is held in Schwetzingen, close to Heidelberg, Germany.

Everyone is invited who is technically interested in CaptainCasa, JavaFX, rich client technology in general. Please view details here: http://www.CaptainCasa.com/cmxi.html

In case of interest register via info@CaptainCasa.com

Regards, Björn

Adaptive Container Components added to control library

Having one layout/component definition which adequately reacts on different sizing scenarios - this is what adaptive layout is about. We now added some new components to enable this within our CatptainCasa Enterprise Client, built with Java FX.

Take a look here: http://www.CaptainCasa.com/ac.html - also including a short demo video. Development still is going on, so adaptive concepts will be also injected into the various grid components.

Regards, Björn

 

Toggle between one/two lines depending on physical space available

Flexibly arrangeing whole blocks of controls according to space available

Demo Application: Datapool Manager - Sharing loosely structured data

For internal communication between ourselves and our users/customers we wrote an application "Datapool Manager" - allowing to define spreadsheet-like data to be shared across users belonging to different organizations. Possible purposes are:

• Task lists
• Collection of any information / analysis result
• ...equipment list
• ...requirements list
• ...list of attendees

...the tpyical issues where you are used to defining a central Excel file and share it "somehow".

Items are tracked (who changed what?), attachments can be added in a simple way and users can discuss / add comments on items.

The client is an FX based program. The server side is a Tomcat server.

Take a look:  http://www.captaincasa.com/dp.

html

Post processing of panoarama photos - FX based tool "Horizon Straightener"

...well, this is some private project - but you may use the results, if you like what I am doing here. (Terms of use: just use it!)

Background:
You may stitch certain photos to form a panorama using software like e.g. Microsoft ICE (Image Composite Editor). There are other tools available, search the Internet for "stitch panorama"... The result of stitching quite often is a panorama, in which the horizon is not perfectly straight. The effort you then have to spend to straighten the horizon is always quite some hell.

This was the reason, why I wrote a JavaFX based tool to simplify this process.

Before - after straightening Screenshot

In the tool you can draw a new horizon line in a simple way - the whole image will be re-arranged using this new horizon line.

Please feel free to use the tool, if you want to use it. Installation is available here: http://captaincasademo.com/horizon/setup_launcherfx.exe

Some documentation is available here: http://captaincasademo.com/horizon/20150619_PanoramaHorizonStraightener.pdf

The tool comes as .exe-setup program for Windows. The default installation location is your user's local directory. Please do NOT install it in Windows/Program Files! The installation contains "everything" that is required to run the tool (including the Java runtime).

Forgive me for not providing a MaxOS installer yet - it's just my lazyness...

10th CaptainCasa Community Meeting - Dec 11, 2014 in Heidelberg

The 10th community meeting is scheduled for Dec 11 (Thursday). The meeting is held close to Heidelberg, details are available via http://www.captaincasa.com/pdf/eclnt_communitymeeting_x.pdf

The meeting's agenda includes:

• JavaFX status quo
• CaptainCasa Enterprise Client on JavaFX - customer scenarios
• CaptainCasa Enterprise Client - news
• Developing for mobile devices - SAPUI5/OpenUI5 as option?

As usual there is one presentation which has nothing to do at all with rich client technology issues: "Industry 4.0 - ...below the buzzwords".

Interested in CaptainCasa / JavaFX / Rich Client Frameworks? - Feel free to register by mail to info@CaptainCasa.com.

CaptainCasa Enterpise Client is a community based rich client framework for Business Applications (http://www.CaptainCasa.com).

App Start - Bringing JavaFX Applications to the End User

How to bring JavaFX applications to the end user's client?

Two possibilities:

1. Install Java (quite up to date version...) on the client. Then use web start or applet.
2. Package your JavaFX application so that the JRE is included (e.g. using bundling) and run it as autarc application on client side.

Let's take a deeper look into both approaches:

1. WebStart/Applet: hmmm... maybe we ourselves are too close to industry/business scenarios, but the installation of a client side Java VM often is some hot discussion. If the discussion is valid or not - who cares at the end, if you are the poor guy to try to make your JavaFX application run at the client side.
   
   And even if the customer agrees to install some up to date Java VM, he/she typically is not the one who is willing to constantly upgrade the VM on all the clients later on... So it's you having to live with the fact that your WebStart/Applet-stared JavaFX application will have to run on many different Java versions...
2. Autarc client application: yes, this often is a nice alternative, because now people are not talking about this client wide Java installation - they more or less treat your application as a native one. Who cares, if there is some bundled JRE which no one outside the application knows about. - And now you are the master of which Java version you use, there is no company policy or whatever you have to fight with.
   
   But...: now you are missing all the nice features that are part of WebStart/Applet: the re-loading of your client application if it changes on server side - the automated roll out of your client software, both for the initial and for the continuous installation.

So, this was the situation we were/are in: for many scenarios we want to go the "autarc application" way, but at same point of time needed something to control the roll out of the client software.

Consequence: we wrote a simple and thin framework which we called "App Start". (We did not check if this name is somehow blocked, so this is an internal project name at the moment!).

It's a client side launcher of a JavaFX application that is kept on server side. The launcher is a small Java programm that is configured by some xml-file, so that it knows what to download from where and after downloading how to start the JavaFX application.
The launcher knows the version stamp of the JavaFX application and with each start checks if the version still is in sync with the server side.

So "App Start" is some mixture out of the "autarc application" mode and the "Web Start" mode. Main difference: "App Start" is only working in the context of one JavaFX client application

As I said: App Start is a quite thin framework. And currently it's only available for Windows scenarios (sorry... but this is the 9x% of our users...), but taking over to other OSs is "just effort". We are open to share everything here - sources, docu, demos etc. are available in the links below. If this is interesting for you: please contact us (info@CaptainCasa.com), maybe this is something we can join forces.

Now the links:

Some slides (PDF)
Tutorial
Test / Demo (currently Windows only)

App Start page: http://www.CaptainCasa.com => Community => App Start Framework - please find all resources (including source code)

...as I said: the framework was born out of our concrete own requirements, but is strictly decoupled from our "normal" JavaFX development. So, it's normal water which we used for cooking, there is not too much magic inside.

One final comment: the picture above only is a simplified view on "App Start" - emphasizing the loading of the JavaFX application. On a long run a client side applications also will require a Java version update (only in the context of this autarc application!) and also an update of the starter program itself. So, in reality, everyhing is versioned and everyhing is synced if required...:

Business Application Workplace with JavaFX

We did some screen recording in order to show how a JavaFX business application workplace might look like.

The video is available here:
http://youtu.be/F77UcB1hNXg

Please note: the video was taken "from the labs"... The JavaFX demo application that is shown in the video is available via http://www.CaptainCasa.com, so you might view and download from there.

Björn

JavaFX and OSM (OpenStreetMap)

In our Swing based client implementation we used a certain library "swingx-ws.jar" around the class "JXMapKit" to render OSM content. The library was coming from the Swinglabs and rendered the maps directly into the Swing-Graphics.

We now wanted to do the same in JavaFX - of course finding out that there is no "native" implementation of an FX-based OSM renderer.

But: there is a nice web browser integration in FX, that I believe everyone in the meantime knows about. And this is also the base for integrating OSM in a really simple way:

In the screenshot you see an FX screen with an embedded WebView-instance showing an OSM map. In the map there are two way points, each one containing certain text information.

When changing the text in the FX grid, then also the text in the OSM map is updated:

When clicking onto a way point's text then the corresponding grid row is selected:

There are not a lot of things at all that are required in order to set up contact between FX and the OSM page:

1. In FX define a WebView instance with a corresponding WebEngine
2. In the WebEngine load an HTML page that uses the map-JavaScript-interface. The following implementation is based on something we found in http://wiki.openstreetmap.org/wiki/DE:Karte_in_Webseite_einbinden. So we did not a lot more than copying and pasting from there...:
   
   <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
   <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="de" lang="de-de" style="height:100%;width:100%;margin:0;padding:0">
   
   <!--
   Based on http://wiki.openstreetmap.org/wiki/DE:Karte_in_Webseite_einbinden
   -->
   
   <head>
     <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
     <meta http-equiv="content-script-type" content="text/javascript" />
     <meta http-equiv="content-style-type" content="text/css" />
     <meta http-equiv="content-language" content="de" />
     <script type="text/javascript" src="http://www.openlayers.org/api/OpenLayers.js"></script>
     <script type="text/javascript" src="http://www.openstreetmap.org/openlayers/OpenStreetMap.js"></script>
   
   <script type="text/javascript">
   function jumpTo(lon, lat, zoom)
   {
       var x = Lon2Merc(lon);
       var y = Lat2Merc(lat);
       map.setCenter(new OpenLayers.LonLat(x, y), zoom);
       return false;
   }
   function Lon2Merc(lon)
   {
       return 20037508.34 * lon / 180;
   }
   function Lat2Merc(lat)
   {
       var PI = 3.14159265358979323846;
       lat = Math.log(Math.tan( (90 + lat) * PI / 360)) / (PI / 180);
       return 20037508.34 * lat / 180;
   }
   function ccCallback(pId)
   {
       ccApp.callback(pId);
   }
   function addMarker(pId,lon, lat, popupContentHTML)
   {
       if (popupContentHTML != null)
       {
           popupContentHTML = "<span onclick='ccCallback(\""+pId+"\")'>" + popupContentHTML + "</a>";
       }
       var layer = layer_markers;
       var ll = new OpenLayers.LonLat(Lon2Merc(lon), Lat2Merc(lat));
       var feature = new OpenLayers.Feature(layer, ll);
       feature.closeBox = true;
       feature.popupClass = OpenLayers.Class(OpenLayers.Popup.FramedCloud, {minSize: new OpenLayers.Size(150, 50) } );
       feature.data.popupContentHTML = popupContentHTML;
       feature.data.overflow = "hidden";
       var marker = new OpenLayers.Marker(ll);
       marker.feature = feature;
       if (popupContentHTML != null)
       {
           var markerClick = function(evt)
           {
               if (this.popup == null)
               {
                   // this.popup = this.createPopup(this.closeBox);
                   // map.addPopup(this.popup);
                   // this.popup.show();
               }
               else
               {
                   this.popup.toggle();
               }
               OpenLayers.Event.stop(evt);
           };
       }
       marker.events.register("mousedown", feature, markerClick);
       layer.addMarker(marker);
       m_markers[pId]  = marker;
       if (popupContentHTML != null)
       {
           var vPopup = feature.createPopup(feature.closeBox);
           map.addPopup(vPopup);
           m_popups[pId] = vPopup;
       }
   }
   function removeMarker(pId)
   {
       var marker = m_markers[pId];
       if (marker != null)
       {
            layer_markers.removeMarker(marker);
       }
       var vPopup = m_popups[pId];
       if (vPopup != null)
       {
           map.removePopup(vPopup);
       }
   }
   function getCycleTileURL(bounds)
   {
      var res = this.map.getResolution();
      var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w));
      var y = Math.round((this.maxExtent.top - bounds.top) / (res * this.tileSize.h));
      var z = this.map.getZoom();
      var limit = Math.pow(2, z);
      if (y < 0 || y >= limit)
      {
        return null;
      }
      else
      {
        x = ((x % limit) + limit) % limit;
        return this.url + z + "/" + x + "/" + y + "." + this.type;
      }
   }
   
   var map;
   var layer_mapnik;
   var layer_tah;
   var layer_markers;
   var m_markers = new Array();
   var m_popups = new Array();
   
   function drawmap()
   {
       OpenLayers.Lang.setCode('de');
       var lon = 0;
       var lat = 0;
       var zoom = 10;
       map = new OpenLayers.Map('map',
       {
           projection: new OpenLayers.Projection("EPSG:900913"),
           displayProjection: new OpenLayers.Projection("EPSG:4326"),
           controls: [
               new OpenLayers.Control.Navigation(),
               new OpenLayers.Control.LayerSwitcher(),
               new OpenLayers.Control.PanZoomBar()],
           maxExtent:
               new OpenLayers.Bounds(-20037508.34,-20037508.34,
                                       20037508.34, 20037508.34),
           numZoomLevels: 18,
           maxResolution: 156543,
           units: 'meters'
       });
       layer_mapnik = new OpenLayers.Layer.OSM.Mapnik("Mapnik");
       layer_markers = new OpenLayers.Layer.Markers("Address", { projection: new OpenLayers.Projection("EPSG:4326"),
                                                     visibility: true, displayInLayerSwitcher: false });
       map.addLayers([layer_mapnik, layer_markers]);
       // position
       // jumpTo(lon, lat, zoom);
       // Position des Markers
       // addMarker(layer_markers, 6.641389, 49.756667,"SERVUS 1");
       // addMarker(layer_markers, 6.741389, 49.856667,"SERVUS 2");
   }
   </script>
   
   </head>
   <body onload="drawmap()" topmargin="0" leftmargin="0" rightmargin="0" bottommargin="0" style="height:100%;width:100%;margin:0;padding:0">
     <div id="map" style="height:100%;width:100%">
     </div>
   </body>
   </html>
   You see that there are two functions "jumpTo" and "addMarker" which are designed to be called from outside.
3. These functions can be called from JavaFX by the WebEngine's capability to execute JavaScript statements in the loaded page, so the Java code might look like:
   
   getEngine().executeScript("jumpTo("+m_longitude+","+m_latitude+","+m_osmzoom+")");
   
4. The callback from HTML to JavaFX is done by a call-back-object which is added to the page by the JavaFX program:
   
   Java(FX) code:
   
       public class CCApp
       {
           public void callback(String id)
           {       
               ...
               // reaction on callback
               ...
           }
       }
   ...
   ...
       JSObject window = (JSObject)m_browser.getNode().getEngine().executeScript("window");
                       window.setMember("ccApp", new CCApp());
   
   
   JavaScript code:
   
   function ccCallback(pId)
   {
       ccApp.callback(pId);
   }
   
5. If there's any difficulty at all, then it is just the timing of operations...: in the FX WebView component you first load the page, then you establish the callback object ("ccApp") and then you call the JavaScript e.g. "jumpTo(...)" in order to show a certain position. To keep this order you have to wait for the page to be completely loaded, and then execute the follow on functions.
   
   This is done by using the WebEngine's listener mechanism:
   
   
       getEngine().getLoadWorker().stateProperty().addListener(new MyStateListener());
   
       class MyStateListener implements ChangeListener<State>
       {
           @Override
           public void changed(ObservableValue<? extends State> paramObservableValue, State from, State to)
           {
               if (to == State.SUCCEEDED)
               {
                   // ...
                   // now the page is loaded and you can "work"
                   // with the page!
                   // ...        
               }       
           }
       }

That's it! Some mini-Javascript processing together with some simple integration between FX and the WebView/WebEngine.


Please note:

Screenshots from our Demo Workplace

Find below some screen shots from our JavaFX based rich client solution, CaptainCasa Enterprise Client 5.0.
Regards, Björn

JavaFX based Rich Client Applications - IX. CaptainCasa Community Meeting

Begin of October 2013 we released version 5.0 of our rich client framework "CaptainCasa Enterprise Client". Version 5.0 now includes a full JavaFX frontend, running as rich client in front of server side business applications.

All tooling is available in JavaFX as well, so the framework is 100% JavaFX!

This year's CaptainCasa Community Meeting on 11th of December 2013 is a good opportunity to get to know the framework, the people around it - and to see a lot of JavaFX being used in the context of (big) business applications...! The community meeting is held in Heidelberg, Germany. More information is available here: http://www.captaincasa.com/pdf/eclnt_CommunityMeeting_IX.pdf

In case of interest please contact info@CaptainCasa.com.



CaptainCasa Demo Workplace, screenshot:

http://www.CaptainCasa.com

CaptainCasa FX Client - Beta Phase started

The JavaFX based client of our rich client framework is now included in the normal installation package - marked as "Beta" of course. After installation you have the option to either use the Swing based client - ...or to use the JavaFX based client.

Both do the same, rendering screens - the layout of screens coming from a central JSF based server. So the rendering result is very similar. OK, with JavaFX it looks smarter - and animations are much nicer... ;-)

We currently concentrate on a Windows based delivery - just to save resources on our side. We will prepare explicit installation scenarios for Linux and MacOS later on. (For the brave ones: there is a zip package containing "everything you need", but some shell scripts to start the FX client are missing...)



A couple of improvements and bug fixing was done in the meantime...:

Images now can be mirrored and sheared just by adding some prefix in front of the image-URL:

This is a general feature of all images, regardless if it's shown in a button or if it's the background for a pane.

It's possible to now to add mapped-areas to an image definition. Each mapped area contains an id and some tooltip information. The user sees the mapped areas on top of the image when moving with the mouse over the corresponding area. Clicks are sent back to the server processing.

The screenshot is showing a gaphics (PNG) which was created by a JFreeChart based reporting on server side. JFreeChart has an interface to collect map-information, which is quite nice. ...OK, we know: JavaFX has some graphics library on its own to produce charts like the one above...! But still, most reporting systems are on server side, producing image output as PNG or whatever file.

Hot-Key definitions were added. Either hot-keys are added directly to cetrain components (e.g. Button) or the arey added to popup menu defintions. There's a flexible way to define which popup menu is valid for which area - so you can define one hot key to be used in different ways on different parts of the screen. (If you want so ...).

The slider and progressbar components are available now as well.

...all in all: everything quite fine from the JavaFX client development...! The beta phase is planned to be finished somewhere mid of Q2/2013.

FX Client Update

Quite a lot functions were added to out FX client in the recent days. You can test the client by going to http://www.captaincasa.com/fxclient.html
Remember: the client is a thin client written in JavaFX, being fed by a JSF based server application running centrally. Please view more information here: http://www.CaptainCasa.com .

The Calendar Field is available, both as stand alone calendar and as popup calendar:

Touch screen support is available. When clicking into corresponding fields a context-specific touch dialog is popping up, allowing direct user input via virtual keyboard.

The schedule control is alive again - supporting all features like drag and drop of items. Both schedule orientation are supported, horizontal and vertical. This is the horizontal example:

 
The paint area component is available, now using JavaFX based animation, which makes it much nicer than the pseudo-navigation that we have to use with our Swing client.

Also have a look into the client's new scrolling through grids. In order to minimize the round-trips to the server, there is a certain "pseudo scrolling" which makes the use much nicer.

Last but not least: we did some test, using the client on a Linux machine - and were very satisfied with results. Basically we did not find any severe problem yet, so compatibility between Windows-JavaFX and Linux-JavaFX is really good! This is the screen shot showing the client running on Ubuntu 12:

"Why we use JavaFX" - Paper

I often get asked why we use JavaFX for the core of our UI processing - and why we don't use HTML5.

I now wrote a paper about this, which is too long to be added into this post, so here is the link: http://www.captaincasa.com/pdf/20130124_JavaFXPositioning.pdf

Maybe you are in the same situation sometimes as well, and maybe some items of the paper may help you in some discussions.

Of course the paper is written from my point of view, which is influenced by having to do with quite complex business applications in the area of  financials, controlling, logistics, human resources, manufacturing execution etc. - And: sorry, I am not a native English speaker...

FX Client Update

We made a new version of our FX client available ("News" on http://www.CaptainCasa.com). The following features are now implemented:

...we now have a real HTML editor - which is part of the standard control set of JavaFX. This was always some lack in the Swing client: the missing of a simple, but working!, HTML editor

...all FILEUPLOAD* and FILEDOWNLOAD* components are available again. Nice: in JavaFX the original file dialogs of the operating system are used for choosing a file - no more home written Swing-Dialogs here anymore!
Unfortunately there is one annoying missing feature: the full file name cannot be proposed into the file selection dialog, but only a directory name can be proposed. This feature is coming with JavaFX 3.

...LONGPOLLING, which is an invisible component, is working

...the grid does not support all internal features yet (e.g. selection without going back to the server), but it re-gains feature by feature! Below you see a rather complex grid - in which a grid is arranged within a grid cell itself. If this has any practical relevance...? I am not too sure...

So, development is going on quite busily. We also made the first checks for memory leaks (and of course found some issues...) - and really feel so good in a Java based  client environment: start Visual VM, start the client, observe it and profile it - and get clear results about instances which are not removed properly...!

Update of FX Enterprise Client demo

The FX Enterprise Client is under busy development! We now published a new version as demo: please follow this link.

A couple of improvements were added. Just to name some:

...grid headers are fully functional (sorting, rearranging columns, resizing columns)

...radio buttons/groups were added

...different type of menus were added

...the generic value help now works

...and the annoying bug that the UI sometimes had problems to accept double-clicks is fixed.

We currently deliver the demo only as installable .exe file. The reason behind is:

• well, first we "love" this way of distributing the system without any pre conditions on client side (...other than it should be some Windows client ;-)...) - it's really getting into the direction of installing an "app" rather than doing a "heavy installation"

But there are also currently some restrictions we are confronted with

• native bundles can only be built on the corresponding platform - we would love to build a MacOS version as well, but (so far) do not have any Mac in our rooms. It would be something verrry nice to be able to build all bundles for all platforms on one device only, but I can definitely understand that there are some problems involved...
• with Windows bundles you have the choice between ".exe" and ".msi". In principal we would prefer ".msi", but we have not managed yet to build an installer that does NOT require admin rights.

So...: development is going on - we'll regularly let you know about the status via this blog.