Attachment | Size |
---|---|
![]() | 803.31 KB |
![]() | 421.9 KB |
![]() | 4.97 MB |
GWT4Titanium Mobile Downloads
EasyGWT Downloads
Flex4j Downloads
Attachment | Size |
---|---|
![]() | 6.4 MB |
GWT4Titanium Desktop
Attachment | Size |
---|---|
![]() | 90.2 KB |
Which of our product is most valuable to you?
GWT4Air Downloads
Attachment | Size |
---|---|
![]() | 21.39 MB |
[New Releases] Touch4j 2.2 released today
Emitrom Support has sent you a group e-mail from www.emitrom.com.
Dear Emitrom community, we are happy to announce the 2.2 release of Touch4j! We have added support for Sencha Touch 2.0.1.1 and Cordova 2.0, and addressed several critical issues of our own. You can read the announcement in our blog, or by pointing your browser to http://emitrom.com/releases/touch4j/2.2
The trial license available with the 2.2 download is good until August 30. Please let us know if you hit any issues; we'll be happy to help you get through them.
The Emitrom Team
[New Releases] Big announcement
Emitrom Support has sent you a group e-mail from www.emitrom.com.
Dear Emitrom community, we wanted to drop you a line to let you know that as of today, September 4, 2012, all of our products are free and open source. The lineup is:
Touch4j 3.0
Titanium4j Mobile 3.0
Titanium4j Desktop 1.2**
Flex4j 2.0
Air4j 2.0
Starting from these versions and moving forward, the license is Apache License v2. Prior versions of the software you may have obtained from us still carry our commercial license. Should you chose to not upgrade to the versions above, please keep in mind that you are bound by the terms of the commercial license.
The announcement can be read at http://bit.ly/T7rr9j
If you have any questions, please don't hesitate to contact us.
The Emitrom Team
**Titanium4j Desktop 1.2 is the only product to not have received a major version, despite what is stated in the announcement.
[New Releases] Announcing Flash4j 3.0 beta
Emitrom Support has sent you a group e-mail from www.emitrom.com.
Dear Emitrom community, we are happy to announce the availability of Flash4j 3.0 beta. Use Java to write stunning desktop browser apps based on Flash.
"When it comes to rich and interactive content for the desktop browser the flash platform is still one of (if not the) best platform on the market. But the close bond between the Flash platform and ActionScript has made it less accessible for other developers (especially Java developers). Flash4j is here to fix this situation. It started as a Java API for Apache Flex, except now we are adding support for other Flash-based libraries to give you even more capabilities. In this release we rewrote the framework from the ground up, fixed a handful of bugs and added an entire set of new features."
http://emitrom.com/flash4j-beta
The Emitrom Team
[New Releases] New Tutorial Posted
Emitrom Support has sent you a group e-mail from www.emitrom.com.
We just thought you'd be curious to check out a new tutorial we posted on Starling:
http://www.emitrom.com/flash4j/tutorials/starling-assets
Check it out! Let us know what you think if you get a chance.
Best regards,
Your friendly Emitrom Team.
Lienzo
Don't know where to get started? Look in the forum for some tutorials!
Attachment | Size |
---|---|
![]() | 315.64 KB |
Java's Future... Lays in Lienzo

Today we are extremely happy to announce the alpha release of our latest product, called Lienzo. Lienzo is a Structured Graphics Toolkit that extends Canvas and is completely built from the ground up using GWT. This is not a wrapper of any sort, it is a pure GWT implementation of Canvas. Lienzo is released under the Apache 2 license and can be used in both open source as well as commercial applications free of charge.
For years we have been constrained to the functionality and specifications provided by HTML elements. The time has come where you can finally let your imagination go wild. Grab your digital brush, get a hold of your Canvas and paint your Mona Lisa! The limit is now really just your imagination. Lienzo brings to your fingertips the full power and flexibility needed to create the next generation of slick, previously unimaginable widgets, games and animations needed to build your dream suite of development products.
This alpha release features:
- Lightning fast shape detection algorithm.
- Supports for multiple Layers.
- z-index reordering: moveUp, moveDown(), moveToTop(), moveToBottom()
- Transforms, rotation, offset, scale for all Shapes.
- Web and Mobile shape events support.
- Support for shadows.
- Support for linear and radial gradients as well as patterns.
- Direct support for shape stroke and filling.
- Support for shape colors and transparency.
- List of implemented shapes:
* Rectangle
* Rounded Corner Rectangle
* Lines
* Dashed Lines
* Support for Line Caps
* Support for Line Joins
* Arcs
* Circle
* Ellipse
* Quadratic Curve
* Polygons
* Stars
* BezierCurve
* Parallelogram
* Slice
* RegularPolygon
- Support for Groups and Groups of Groups.
* Group as many shapes as you want and even Groups of Groups and treat them as a single entity.
- Direct Dragging Support for Web and Mobile.
- Text support with Horizontal and Vertical Alignment.
- Text measure support for both width and height.
- Scaled Text
- Image support based on URL and even ImageResource.
- Image Dragging support.
- Built-In Image Filters
- Drag constraint (bounds, vertical and horizontal)
- Video support
- Built in JSON serialization for the entire viewport of elements.
* Serialize your Lienzo View and persist it locally or over the wire via JSON.
There is a lot more coming in Lienzo. Just to name a few things: animations, collision detection, and more! Lienzo is revolutionizing the way we write software in Java; it truly embraces Java's "Write Once, Run Anywhere" motto. The same code can be run in a mobile, web, or desktop environment. Say hello to a specification-bound API!
The future for Java is now. The future for Java is here, with Lienzo and the undeniable power of canvas.
Take a look at the Lienzo Explorer (check out the source code) at http://emitrom-lienzo.appspot.com, and download lienzo from http://emitrom.com/lienzo/download
Stay warm, stay coding!
The Emitrom Team
[New Releases] Introducing Lienzo
Emitrom Support has sent you a group e-mail from www.emitrom.com.
Hello dear Emitrom community member! It is with tremendous pleasure that we introduce to you... *drum roll*... LIENZO.
Lienzo is a structured graphics toolkit based on HTML5's Canvas, implemented in GWT. The power of Canvas is now brought to the Java world so that Canvas-based apps can be written for mobile devices (thanks to our Cordova binding in Java), web apps, and desktop apps. Never has the adage of "Write Once, Run Anywhere" been truer than today. With virtually no changes, your code can run in all spaces, unscathed. Lienzo is licensed under the Apache 2 license, which means it is free for commercial use. Currently in alpha stage, Lienzo is poised to get some really cool features before it goes GA. Get it today, and help us shape the future!
http://emitrom.com/announcements/lienzo/alpha
We are ramping up tutorials and documentation, but we wanted to get this out sooner rather than later. Check the link above for an explorer that briefly demonstrates the things you can do with Lienzo.
Happy coding!
The Emitrom Team
Pilot 2.2 beta
The Pilot API is Emitrom's Java binding for the Cordova and Google Maps API.
Attachment | Size |
---|---|
![]() | 2.12 MB |
GWT4Titanium Mobile Downloads
Please find the release notes for version 1.2.1 here.
Attachment | Size |
---|---|
![]() | 803.31 KB |
![]() | 421.9 KB |
![]() | 4.97 MB |
EasyGWT Downloads
TEMPORARILY UNAVAILABLE
Flex4j Downloads
Attachment | Size |
---|---|
![]() | 6.4 MB |
Announcing Flash4j 3.1

We're very excited to announce the General Availability of Flash4j 3.1!
Flash4j is our Java-based application toolkit that leverages the GWT Toolkit to help developers build high performance Rich Internet Applications for the Desktop.
The goal of Flash4j is to leverage Flash and HTML5 in an innovative way, helping you build stunning web applications. At Emitrom, we believe in combining Flash and HTML5 to create amazing products instead of having a Flash vs HTML5 approach. Lets see what is new in this release.
Developing in the Open
Like all our products, the codebase for Flash4j is also hosted on GitHub! This gives everyone the possibility to follow the framework's evolution and even contribute to it.Client Side File IO (PDF,Excel) for any Web Application
The ability to read and write files on the client is a powerful feature for any web application. Take a reporting tool, for example. Being able to generate reports on the client without hitting the server is a big performance boost (your sever will thank you).Flash4j has always had client-side file generation (specially PDF and Excel), but this feature required the use of the Flex framework. With release 3.1 we are bringing this capability to any web application, as shown below.
package com.emitrom.flash4j.demo.client;
import com.emitrom.flash4j.clientio.client.ClientIO;
import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.RootPanel;
public class ClientIOExample implements EntryPoint {
@Override
public void onModuleLoad() {
// initialize the ClientIO module
ClientIO.init();
Button b = new Button("Click Me");
b.addClickHandler(new ClickHandler() {
@Override
public void onClick(ClickEvent event) {
// create a PDF File
PDF pdf = new PDF();
pdf.addPage();
pdf.setTextStyle(new RGBColor(0x000000));
pdf.setFont(new CoreFont(), 10);
pdf.addText("Hello World");
ClientIO.saveFile(pdf.save(), "file.pdf");
}
});
RootPanel.get().add(b);
}
}
The code above creates a PDF file on the client in a regular GWT application!
ClientIO can also be used to read files.
package com.emitrom.flash4j.demoo.client;
import com.emitrom.flash4j.clientio.client.ClientIO;
import com.emitrom.flash4j.core.client.events.Event;
import com.emitrom.flash4j.core.client.events.handlers.EventHandler;
import com.emitrom.flash4j.core.client.net.FileFilter;
import com.emitrom.flash4j.core.client.net.FileReference;
import com.emitrom.flash4j.core.client.utils.ByteArray;
import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.RootPanel;
public class ClientIOExample implements EntryPoint {
@Override
public void onModuleLoad() {
ClientIO.init();
Button b = new Button("Click Me");
b.addClickHandler(new ClickHandler() {
@Override
public void onClick(ClickEvent event) {
final FileReference fileReference = ClientIO.browse(new FileFilter("My File", ".txt"));
fileReference.addEventHandler(Event.SELECT, new EventHandler() {
@Override
public void onEvent(Event event) {
fileReference.load();
fileReference.addEventHandler(Event.COMPLETE, new EventHandler() {
@Override
public void onEvent(Event event) {
ByteArray data = fileReference.getData();
String content = data.readUTFBytes(data.getBytesAvailable());
Window.alert(content);
}
});
}
});
}
});
RootPanel.get().add(b);
}
}
In the previous sample we read a text file from the user's computer and show an alert with its contents. Again, no server roundtrip, thus saving bandwidth and server processing power! This feature can be used in combination with any web library. Regular GWT, ExtGWT, SmartGWT, Ext4j... You name it. The ClientIO API can even be exported to native JavaScript using the GWT Exporter project. How powerful is that?
Core Flash support
In our previous releases the core Flash API was only exposed through our Flex module, which meant one had to load the entire Flex framework even if only core Flash functionalities were needed. In 3.1 we are introducing the Flash Core module. This module gives access to the Flash platform without any dependency to Flex, which results in a much faster load time.
package com.emitrom.flash4j.app.client;
import com.emitrom.flash4j.core.client.display.Graphics;
import com.emitrom.flash4j.core.client.display.Shape;
import com.emitrom.flash4j.flash.client.FlashEntryPoint;
import com.emitrom.flash4j.flash.client.FlashRootPanel;
public class FlashApp extends FlashEntryPoint {
@Override
public void onLoad() {
Shape s = new Shape();
Graphics g = s.getGraphics();
//draw a green circle
g.beginFill(0x00FF00);
g.moveTo(250, 0);
g.curveTo(300, 0, 300, 50);
g.curveTo(300, 100, 250, 100);
g.curveTo(200, 100, 200, 50);
g.curveTo(200, 0, 250, 0);
g.endFill();
s.setXY(300, 300);
FlashRootPanel.get().addChild(s);
}
}
Here we used core Flash APIs to draw a circle on te screen. All in Java!
Support for Apache Flex 4.9
This release of Flash4j adds support for the latest stable release of Apache Flex (4.9).
UI Binder Support for Flex !
When we created the Java API for Flex one of the most requested features was MXML support. In the ActionScript world MXML allows developers the express the Flex UI in a declarative way, which is less verbose and more intuitive, especially for non programmers.
We heard you and added UI Binders support for Flex!
As in MXML, UI Binders enables a declarative way to define the User Interface in a GWT project. Flash4j introduces a custom parser to enable the GWT compiler to generate a Flex UI from the UI Binders XML declaration.
<!DOCTYPE ui:UiBinder SYSTEM "http://dl.google.com/gwt/DTD/xhtml.ent">
<ui:UiBinder
xmlns:ui="urn:ui:com.google.gwt.uibinder"
xmlns:mx="urn:import:com.emitrom.flash4j.flex.client.ui.mx">
<mx:Panel ui:field="panel" title="Flash4j 3.1 and UI Binder" verticalCenter="0"
horizontalCenter="0" percentWidth="50"
percentHeight="50" status="Emitrom">
<mx:Label fontSize="20" centered="true" text="Hello World" />
</mx:Panel>
</ui:UiBinder>
As you can see, the code is simpler and less verbose than if it was written in pure Java. Below is the result.
Google Maps Support for Flex
In September 2011, Google announced the deprecation of the Google Maps API for Flash in favor of a JavaScript API. This news left Flex developers wondering how they would integrate Google Maps in their applications.Wonder no longer! Flash4j 3.1 adds a seamless integration with the Google Maps JavaScript API.
New in the framework is a new MapWidget that can be used to display a Google Map into any Flash4j based Flex application. The Map can then be accessed and modified using the Maps API from Emitrom's Pilot library.
public class Flex4jExplorer extends FlexEntryPoint {
@Override
public void onLoad() {
FLEX.getRootPanel().setBackgroundColor(Color.BURLYWOOD);
Panel container = new Panel("Flash4j 3.1 - Google Maps Support");
container.setStatus("Emitrom");
container.setPercentSize(80, 70);
container.setCentered(true);
MapWidget mapWidget = new MapWidget();
mapWidget.asUIComponent().strech();
mapWidget.addMapLoadHandler(new MapLoadHandler() {
@Override
public void onMapLoad() {
GMap googleMap = new GMap(mapWidget.getMap());
googleMap.setMapType(MapTypeId.HYBRID);
}
});
container.addElement(mapWidget);
FLEX.getRootPanel().addElement(container);
}
}

Java Bean support for List Based Component
Data driven components like List or DataGrid can only work with BaseModel instances. BaseModel wraps a lightweight JavaScripObject allowing easy data transmission between GWT and the Flash player. Although this approach works, it forces you to create a class that extends BaseModel and some kind of Data Transfer Object to turn your Java Bean into a BaseModel.
What is missing is a way to use your Java Beans as is, without having to extend the Flash4j base classes.
With the 3.1 release of Flash4j, it is now possible to use any Java Beans for data-bound components such as List and DataGrid. This allows you to send your Java Beans from the server to the client using GWT RPC.
Lets say you have the following Java Bean
public class SuperHeroe {
private String realName;
private String nickName;
public SuperHeroe() {
}
public SuperHeroe(String realName, String nickName) {
super();
this.realName = realName;
this.nickName = nickName;
}
public String getRealName() {
return realName;
}
public void setRealName(String realName) {
this.realName = realName;
}
public String getNickName() {
return nickName;
}
public void setNickName(String nickName) {
this.nickName = nickName;
}
public static List<SuperHeroe> getList() {
List<SuperHeroe> list = new ArrayList<SuperHeroe>();
list.add(new SuperHeroe("Logan", "Wolverine"));
list.add(new SuperHeroe("Scott Summers", "Cyclops"));
list.add(new SuperHeroe("Professor Charles Francis Xavier", "Professor X"));
list.add(new SuperHeroe("Jean Grey-Summers", "Marvel Girl"));
list.add(new SuperHeroe("Kurt Wagner", "Nightcrawler"));
list.add(new SuperHeroe("Robert Louis Drake", "Iceman"));
list.add(new SuperHeroe("Ororo Lqaldi T' Challa-Wakandas", "Storm"));
list.add(new SuperHeroe("Henry Phillip McKoy", "Beast"));
return list;
}
}
As you can see this is a plain old Java object not extending any of Flash4j classes. The 'getList' method could be a service method that retrieves the list of superheroes from a database.
With Flash4j 3.1 you can use this class directly in a DataGrid without any modification.
public class Flex4jExplorer extends FlexEntryPoint {
@Override
public void onLoad() {
FLEX.getRootPanel().setBackgroundColor(Color.BISQUE);
Panel container = new Panel("Java Beans support for Grid");
container.setStatus("Emitrom");
container.setPercentSize(80, 70);
container.setCentered(true);
//Use the model localtor to contrust BaseModel out of the List of superheroes
List<BeanModel> superHeroes = ModelLocator.locate(SuperHeroe.class).createModel(SuperHeroe.getList());
DataGrid dataGrid = new DataGrid(superHeroes);
dataGrid.setColumns(new DataGridColumn("RealName", "realName"), new DataGridColumn("NickName", "nickName"));
dataGrid.setStreched(true);
FLEX.getRootPanel().addElement(container);
}
}
On line 12 you see how we use the ModelLocator class to turn the List of SuperHeroes into a list of BeanModel. The conversion from POJO to BeanModel is done automatically for you. Below is the result.
Flash4j also gives you the ability to retrieve the original bean from the BaseModel
dataGrid.addEventHandler(ListEvent.ITEM_CLICK, new EventHandler() {
@Override
public void onEvent(Event event) {
ListEvent e = ListEvent.cast(event);
BeanModel model = (BeanModel) dataGrid.getData().get(e.getRowIndex());
SuperHeroe sh = model.getBean();
Alert.show(sh.getRealName() + " a.k.a " + sh.getNickName(), "You selected !!");
}
});
Flash4j Roadmap
As you can probably imagine, we have been hard at work to make Flash4j the best tool for writing desktop-based Rich Internet Applications. Still, we are planning on adding support for more amazing features in the future, so stay tuned to this space or in our Google+ community.Flash4j brings a lot of exciting new capabilities and we hope you enjoy using it.
Happy coding! The Emitrom Team
Announcing Touch4j 4.2.2.1 and Pilot 2.2.7

Hello folks,
We are pleased to announce the release of Touch4j 4.2.2.1!
Touch4j is our enterprise leading web application framework that leverages the GWT and Sencha Touch frameworks to help developers build high performance HTML5 mobile web applications using Java.
Support for Sencha Touch 2.2.1
This release of Touch4j is compatible with the latest stable release of Sencha Touch (2.2.1). You may notice the versions of Emitrom libraries that bind other frameworks to include their version number as part of the overall string. In the case of Touch4j, this means 4.2.2.1. Version 4 is the major version for the binding, and 2.2.1 is the version of Sencha Touch that is supported. Again, this is a theme that you will start seeing in libraries that are bindings to others (e.g., Touch4j, Titanium4j, and Flash4j).
Sencha Touch 2.2 added support for BlackBerry and Windows Phone, and Touch4j now gives you access to this features.
Enhanced Charting Support
In this release we improved the charting API. Fixed some bugs a made it more intuitive to use.
Panel panel = new Panel(Layout.FIT);
ToolBar tb = new ToolBar("Touch4j Charting");
panel.add(tb);
panel.add(ChartCreator.createLineChart());
ViewPort.get().add(panel);
A real world example can be seen here.
JavaBean support for data driven components
Data driven components like ListDataView or Grid can only work with BaseModel instances. BaseModel wraps a lightweight JavaScripObject allowing easy data transmission between GWT and Sencha Touch. Although this approach works, it forces you to create a class that extends BaseModel and some kind of Data Transfer Object (DTO) to turn your JavaBean into a BaseModel.
What is missing is a way to use your JavaBeans as is, without having to extend the Touch4j base classes.
With the 4.2.2.1 release of Touch4j, it is now possible to use any JavaBeans for data-bound components. This allows you to send your JavaBeans from the server to the client using GWT RPC or any other GWT server mechanism.
Lets assume you have the following JavaBean
public class Person {
private String lastName;
private String firstName;
public Person() {
}
public Person(String lastName, String firstName) {
super();
this.lastName = lastName;
this.firstName = firstName;
}
/**
* @return the lastName
*/
public String getLastName() {
return lastName;
}
/**
* @param lastName
* the lastName to set
*/
public void setLastName(String lastName) {
this.lastName = lastName;
}
/**
* @return the firstName
*/
public String getFirstName() {
return firstName;
}
/**
* @param firstName
* the firstName to set
*/
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public static List<Person> getList() {
List<Person> list = new ArrayList<Person>();
list.add(new Person("Cuban", "Marc"));
list.add(new Person("Wayne", "Bruce"));
list.add(new Person("Doe", "John"));
list.add(new Person("Muster", "Max"));
return list;
}
}
As you can see this is a plain old Java object not extending any of Touch4j classes. The 'getList' method could be a service method that retrieves the list of persons from a database.
With Touch4j 4.2.2.1 you can use this class directly in a ListDataView(or any other data driven component) without any modification.
public class HelloTouch extends TouchEntryPoint {
@Override
public void onLoad() {
List<BeanModel> data = ModelLocator.locate(Person.class).createModel(Person.getList());
Store store = new Store(data);
final ListDataView listView = new ListDataView("{firstName} - {lastName}", store);
TabPanel tabPanel = new TabPanel();
tabPanel.setTabBarPosition(Alignment.BOTTOM);
TabItem item = new TabItem("Users");
item.setIconCls(TouchIcons.USER);
item.add(listView);
tabPanel.add(item);
ToolBar tb = new ToolBar("Emitrom - Team");
tabPanel.add(tb);
ViewPort.get().add(tabPanel);
}
}
On line 6 you see how we use the ModelLocator class to turn the List of persons into a list on BeanModel. The conversion from POJO to BeanModel is done automatically for you. Below is the result.
Touch4j also gives you the ability to retrieve the original bean from the BaseModel
listView.addItemTapHandler(new DataViewItemTapHandler() {
@Override
public void onItemTap(DataView dataView, int index, Element element, BaseModel record,
EventObject eventObject, Object eOpts) {
BeanModel beanModel = (BeanModel) store.getAt(index);
Person person = beanModel.getBean();
Window.alert(person.getFirstName());
}
});
Component Support in ListDataView
Being able to display UI Compoments in a ListDataView has been of the most recurrent request from the community.
We are glad to announce that as for Touch4j 4.2.2.1 UI Components are now supported in a ListDataView row. Unlike in native Sencha Touch, the API is simple
and intuitive.
listView.setUseComponents(true);
listView.setItemComponentRenderer(new ListItemComponentRenderer() {
@Override
public List<Component> getComponents() {
List<Component> toReturn = new ArrayList<Component>();
toReturn.add(new Button("Delete", UI.DECLINE));
toReturn.add(new Button("Edit", UI.CONFIRM));
return toReturn;
}
});
Swipe to delete plugin
Based on the new UI Components support in the ListDataView item we added a new pluging the ListDataView: The SwipeToDelete plugin.
listView.setPlugins(new PullRefresh(), new SlideToRemove());
We are convinced that you will make good use of this new plugin.
UberGrid Support
This release also add support for the awesome UberGrid component. If you are looking for a powerful grid component to display your data, UberGrid is the right component for you. Please visit the UberGrid page for details on pricing; it is worth mentioning we have no connection to the Bryntum folks, we just think their component is very nice, and want to provide that option to Touch4j users.
List<BeanModel> data = ModelLocator.locate(Person.class).createModel(Person.getList());
final Store store = new Store(data);
UberGrid grid = new UberGrid();
grid.setStore(store);
UberGridColumn col = new UberGridColumn("Firstname", "firstName");
col.setFlex(1);
grid.addColumn(col);
col = new UberGridColumn("LastName", "lastName");
col.setFlex(1);
grid.addColumn(col);
TabPanel tabPanel = new TabPanel();
tabPanel.setTabBarPosition(Alignment.BOTTOM);
TabItem item = new TabItem("Users");
item.setIconCls(TouchIcons.USER);
item.add(grid);
tabPanel.add(item);
ToolBar tb = new ToolBar("Emitrom - Team");
tabPanel.add(tb);
ViewPort.get().add(tabPanel);
Cordova 2.7 Support!
Going native is an important part of mobile development. Emitrom makes it easy by providing a 100% implementation of the Cordova (PhoneGap) API.
This is made possible through version 2.2.7 of out Pilot library. As with Touch4j, Pilot bears an Emitrom version (2), plus the version of the library it supports (2.7). As such, this release of Pilot is 2.2.7.
if (Device.isReady()) {
Notification.get().alert("Touch4j 4.2.2.1", "You are using " + Device.get().getCordovaVersion());
}
In this release of Pilot we also added support for the PhoneGap Build PushNotification.
Also, we especially want to thank Mvniekerk for his incredible work (among others) on the BlackBerry support for PushWoosh. The PushPlugin from PhoneGap Build does not have support for BlackBerry, so Michael's contribution is a welcome addition to Pilot.
The future
Again, we thank the community for your bug reports, questions, and suggestions which have helped us in shape and deliver this release. Pilot 2.2.7 and Touch4j 4.2.2.1 are a big advancement in our product line and we hope you enjoy using it. Still, we are planning on adding support for more amazing features in the future, so stay tuned to this space or in our Google+ community.
Download Touch4j 4.2.2.1 and Pilot 2.2.7 today.
Happy coding!
The Emitrom Team
Client-side IO with GWT

Reading and writing files is a very recurrent action in web applications.
Because the browser (for security reasons) prevents direct access to the user's machine from a web application, this has to be done on the server. HTML5 introduced a promising File API but that API is still very limited and not supported by all browsers. Plus, the HTML5 File API requires the use of a modern browser which is not always available.
While generating every file on the server works pretty well, it requires a lot of ressources. Beeing able to read and write files on the client without hitting the server is a feature that helps your application scale better, since you don't need to worry about server-side resources as your user base grows.
Now how do you generate file on the client in a cross-browser way ?
ClientIO to the rescue
A couple of weeks ago we introduced version 3.1 of Flash4j, our Java API for the Flash Platform. As we stated in the release announcement the goal of Flash4j is to help developers combine HTML5 and Flash technologies in an unique way to create awesome experiences.
Part of Flash4j 3.1 is a new GWT module called ClientIO. This module implements a simple GWT widget that gives access to the Flash player File System API and allows developers to read and write files on the client from any GWT-based applications. On top of the core Flash File API, ClientIO gives access to the Alive PDF and as3Xls libraries, enabling the creation of PDF and Excel files right on the client!
A Simple Example
Before using ClientIO we first need to download Flash4j and add it to the project's classpath.
Next step is to inherit the ClientIO module
<inherits name='com.emitrom.flash4j.clientio.ClientIO'/>
In the onModuleLoad method we then need to initialize the ClientIO library.
public class Gwtfile implements EntryPoint {
/**
* This is the entry point method.
*/
public void onModuleLoad() {
ClientIO.init();
//rest of the code ommited
}
}
Our example will be a slightly modified version of the default sample that gets created by the GWT Plugin for Eclipse. Instead of sending the entered text to the server we will create a PDF file.
// Create a handler for the sendButton and nameField
class MyHandler implements ClickHandler, KeyUpHandler {
/**
* Fired when the user clicks on the sendButton.
*/
public void onClick(ClickEvent event) {
writeToPDF();
}
/**
* Fired when the user types in the nameField.
*/
public void onKeyUp(KeyUpEvent event) {
if (event.getNativeKeyCode() == KeyCodes.KEY_ENTER) {
writeToPDF();
}
}
/**
* Send the name from the nameField to the server and wait for a
* response.
*/
private void writeToPDF() {
// First, we validate the input.
errorLabel.setText("");
String textToServer = pdfField.getText();
if (!FieldVerifier.isValidName(textToServer)) {
errorLabel.setText("Please enter at least four characters");
return;
}
sendButton.setEnabled(false);
// Then, we write to a PDF file on the client
PDF pdf = new PDF();
pdf.addPage();
pdf.setTextStyle(new RGBColor(0x000000));
pdf.setFont(new CoreFont(), 10);
pdf.addText(textToServer);
// save the file
ClientIO.saveFile(pdf.save(), "file.pdf");
}
}
As you can see on line 35 the API is simple and easy to use.
ClientIO offers way more features that we can cover here and we are looking to add even more powerful features.
A real world example of ClientIO at work can be seen here and here.
We can't wait to see what you will build with this new capabilityHappy coding!
The Emitrom Team