We made some smaller changes to VisionX that supports developers in their daily work. The first improvement is that database connection messages will be developer friendly (original message) instead of user-friendly (simple language). It'll be easier to debug VisionX applications because we've added debug information to included Open Source projects like JVx, JVx.vaadin, ...
VisionX enterprise comes with source code of our Open Source projects like JVx and JVx.vaadin. The source code matches the binary versions, used in VisionX, and a developer has exactly the same code to debug problems. It was possible to get the source code from our sourceforge project site, but you didn't know the exact revision.
We've also added VisionX API jar and javadoc archives to enterprise VisionX. That makes it easier to develop modules or AddOns (will be a new feature in upcoming releases).
With VisionX 2.0 it'll be possible to access the embedded database directly with an integrated database editor. We use an existing tool with the name pgAdmin (see developer site). It's a very popular tool, especially for PostgreSql users.
Here's a screenshot of the integration
 pgAdmin III |
The tool will be available in every application and the menu item will be available in Edit menu.
The tool pgAdmin is open source and was not developed by SIB Visions! It was integrated for better database support and for all database lovers.
VisionX 1.2 will be VisionX 2.0 because it's more than just a minor update. It's too powerful for 1.x and has awesome new features. We have so many new features and didn't release smaller version updates... but we started with weekly builds for our customers in decemter 2013.
Most of our customers have access to early release versions with all available features. This is not usual for product development companies, but we develop high quality software and take the risk 
We've releasd a bigger update of VisionX with the version number 1.2.136 in december for all our customers. So please check your download areas.
Some new features for the next weekly build will be:
We have more amazing features, that covers reporting and new JVx features. If you have access to VisionX' nightly builds, simply check the changelog of VisionX and ProjX for details.
First of all, we don’t have JVx 2.0 for you. We planned it for 2013 but it wasn’t possible to finish everything.
We made some smart design decisions and put more time in our vaadin UI (especially push support) and our Liferay integration. Especially LR integration is now incredibly good. We support Live Preview of work-screens without deployment. It makes developers happy!
Sorry for the delay, but we have some nice extra features for 2.0 in the queue like buffer caching for queries.
Our plan is that JVx 2.0 will be released together with VisionX 2.0. This will happen in Q1/2014.
But don’t be sad. We have a new JVx release for you. It’s 1.2.1 (see Changelog). We also have Vaadin UI 1.1 for you (see Changelog).
VaadinUI 1.1 was built with vaadin 7.1.7. The current vaadin version is 7.1.9. We'll update to the latest vaadin with vaadin UI 1.2.
Both releases will be available on 24.12.
Merry christmas 
Our vaadin UI implementation is ready for Liferay portals because vaadin has built-in support for portlets and we added some magic to our UI implementation. With our last integration project we made it possible to run a JVx screen without changes as Liferay portlet. It was amazing but there was a limitation to one screen. It wasn't possible to open screens from the portlet itself, because we didn't implement this feature.
With our current implementation, we support whole applications running as portlet. It's possible to open other screens directly from your portlet. It's also possible to navigate between screens but with full JVx security mechanism (which is directly connected to Liferay security). Now it's really amazing:
We have two screenshots for you. The first shows the embedded variant with two opened screens, but only one screen is visible. It's possible to navigate between screens via navigation links. The second one shows the window variant. Every new screen will be opened as separate window.
 Screen embedded |
|
 Screen as window |
We fully support Vaadin' push support with current JVx *nightly* builds (see JVx with vaadin UI and server-side push). We had some problems with manual push mode because of some strange implementations of atmosphere in vaadin. We found a better solution to be independent of vaadin changes (should work with 7.1.8 and later).
No we automatically push if you use standard threads or threads, created via VaadinFactory. It's also possible to use JVx' callback mechanism for push operations. If you won't use threads in your client application, simply make an async server call. The server implementation automatically starts a new thread and executes the task. The server will notify the client after the task is finished. This is a little bit strange because client and server run on the application server, if you use our vaadin UI. If your JVx client retrieves the result of an async call, it will automatically push the results to the vaadin client. This makes the whole application very smart and live.
It's very easy to work with async calls in JVx. Simply use a callback listener:
getConnection().callAction(new ICallBackListener()
{
@Override
public void callBack(CallBackEvent pEvent)
{
butCallBack.setImage(IMAGE_YESNO);
}
},
"asyncServerAction");
The server method in Session LCO:
public int asyncServerAction
() throws Exception
{
Thread.
sleep(5000
);
return ++count;
}
We didn't change JVx' APIs to support vaadin push. It works behind the scenes and we simply love it.
Use our nightly builds to see how it works.
We build all our OSS projects automatically every day, but only JVx binaries were available for download so far. We wanted to let you know that we added JVx.vaadin and JVx.help to the nightly-build download area. Check https://dev.sibvisions.com/jvx.nightly/ to get access to our nightly build binaries.
Currently we only push JVx snapshot binaries to maven central, but we'll do the same with JVx.vaadin or online help in a few weeks. So keep reading this blog to get the latest news or follow us on Twitter.
Vaadin supports "push" - since 7.1 - but JVx doesn't have an API for that. It's technology dependent and we usually not need it on client-side of an application. It would be useful for the server-side of JVx applications, but that's a different thing. I want to write about server-side push for UI changes.
If you use threads in your application, to update the UI, it's not a problem if you use a desktop technology like Swing UI. The UI is always up-to-date. If you use vaadin UI, it's not the case, because vaadin UI runs on an application server (= server machine) and vaadin client runs in your browser as Javascript code (= client machine). The thread runs on the server machine and doesn't update the client machine automatically. The client retrieves all changes with next client request. This is sometimes too late. With server-side push it's possible to update the client machine immediate, if you use pure vaadin.
With our next vaadin UI release, it's also possible to use server-side push of vaadin to update the client machine. It's very easy to use and also is technology independent, but we didn't introduce new APIs
How it works?
Create a new thread, through your factory and use invokeLater to update the UI. You always should use invokeLater to update the UI (no difference if you use swing or other desktop technologies).
UIComponent.invokeInThread(new Runnable()
{
public void run()
{
try
{
while (!ThreadHandler.isStopped())
{
Thread.sleep(2000);
UIComponent.invokeLater(new Runnable()
{
public void run()
{
iCount++;
label.setText("Push: " + iCount);
}
});
}
}
catch (InterruptedException ie)
{
info(ie);
}
}
});
If push is enabled, above code pushes the UI changes immediate to the client machines. To enable server-side push, simply add following to your servlet configuration in web.xml:
<init-param>
<param-name>pushmode
</param-name>
<param-value>automatic | manual
</param-value>
</init-param>
<async-supported>true</async-supported>
It's also possible to use vaadin push without JVx' mechanism (pure vaadin). To see how this works, read following issue: Server-side refresh.
 Winner IT/E-Commerce |
|
Wir sind seit gestern die Gewinner der Spezialategorie IT/E-Commerce des GEWINN Jungunternehmer Wettbewerbes - 2013.
Wir konnten uns gegen eine sehr starke Konkurrenz durchsetzen und freuen uns dementsprechend über die Auszeichnung.
Zum Gewinn haben unser Produkt VisionX und unsere OpenSource Strategie beigetragen. Als eines der wenigen österreichischen Unternehmen entwickeln wir Technolgien für die Software Entwicklung.
Durch die Auszeichnung wurden auch unsere konsequente Vorgehensweise und unsere hohen Qualitätsansprüche belohnt. Nicht zuletzt deswegen sind wir sehr stolz auf diesen Preis. |
| |
In feierlichem Ambiente und mit gekonnt witziger Moderation wurde die Preisverleihung durchgeführt.
Prize-giving
Our new JVx' pages are online: http://www.sibvisions.com/jvx
We reduced everything to a bare minimum and it's now much better than before. We added missing information like usage with Maven, Nightly builds, repositories for our demo application. The demo application is now up-to-date. We replaced our showcase application with our new ERP demo application.
We have a new JVx' video that shows all JVx features and projects like Online Help.
Have fun with JVx
News | rjahn | 07/02/2014 | 
Comments (0) 
RSS-Feed