This seems to come up every once in a while, especially outside US and UK. People start looking at the PDF generating libraries, and find that when they use a non-latin character it stops to work. It needs some special care but it is really easy to get it working, I’m going to show how to do it, step by step, when using purepdf (a port of iText

Getting ready

You can find purepdf on google code. Once you download the zip you’ll find purePDF.swc and purePDFont.swc, for this example you’ll only need the first one so put it in your projects lib folder and you’re ready.
The next thing you need is a font to use, I’ll be using Ubuntu-L.ttf which can be downloaded from font.ubuntu.com, just drop it in the project. You can use any font, as long as it supports the charset you’ll be using. At this point my project looks something like this:

Flex stuff

To make the example work, we need some basic UI which, in the example, begins and ends with:

As you can see, the text has some polish characters (as Flex text is UTF encoded there’s no problem with putting what you need there). The other thing worth noting is that we’re going to be creating the PDF after a click, that’s important as we want to save the pdf to the user system and that’s only possible when the save function is being called after an user interaction.

What’s left to do now is embedding the font:

The mineType is required to stop Flex from handling the fonts as a font ¹. That’s all the setup we need no we can get to the purepdf code.

Purepdf code

The code that’s needed to start using the font and generatign the pdf takes around 10 lines, I’ll paste it first and than add comments.

In lines 4-9 we’re using the embedded font file to create an instance of an org.purepdf.Font, that’s all you need to do to start using the font. The rest of the code is standard purepdf code.

11 – creates a buffer to hold the pdf file

12 – creates a PDFWriter linked with that buffer and sets the size of the pdf page

13 – gets the PDFDocument from the writer

14 – opens the document

15 – adds a paragraph to the open document. Here’s the important change if you already have some code written, you need to set the second parameter which is the font you’re wanting to use. If it supports the chars you’re using there will be no problem.

16 – closes the document

and 20-21 save the document to the user filesystem.

That’s it, the PDF you get in result looks something like this:

Hopefully this get’s people started. You can find many more examples and tutorials on the google code page for the project.

Download source code.

The socket api is relatively simple, but I couldn’t find a simple step by step tutorial on getting sockets working. The basic idea was to create an app that can send text to connected clients (which I’ll be using to send code while teaching a Flex class), and getting that basic functionality working is amazingly simple with AIR 2+.

The config

To make life easier, first I’ve created a class that will hold the configuration for the socket, it’s nothing interesting, but as it will be used later, I’ll put it at the top. There are a few things to keep in mind while choosing the port – it needs to be smaller than 65536 and should be bigger than 1024 (see docs) and ports can’t be shared, so you need to make sure that the port you’re choosing isn’t already used ¹.

The server – setup

Creating the server is really easy. We just need to set up an instance of the ServerSocket class, and start listening and handling incoming connections.

As it’s supposed to push data to multiple clients, here’s the code to keep track of the connections,

The client – setup

Setting up a client is as easy, if not easier. You just need to create a Socket, add event listeners to link some logic to it and connect to the server (using it’s address and port)

We can create functions with trace statements to check if the connection works and, as the only thing this server will be sending will be strings, output the data is being sent.

The server – finishing

The last thing we need to do is send the data to sockets, we’re going to use the writeUTF ² of the socket. Notice that this function is called on each of the connected sockets (stored in the clientSockets collection) and not on our ServerSocket instance. It’s also important to flush the data to the socket once finished to make sure the data is sent.

That’s it, now we have a fully working server which can push data to clients over TCP.

Please remember that this is a very basic example with no code for error handling, etc. Just enough code to get it working. The very last thing to do is make sure we release the port once the server application closes.

The source code has some additional code for the UI.
Download source code.

When displaying data in a DataGrid you can now reach into the inner structure of the data item while using the dataField property.

Let’s say your data is:

If your data has nested fields, like the short one above you can use simple dataField to reach for them, like this:

I’m almost sure this wasn’t possible the last time I’ve tried this with some previous version of Flex SDK.

I’ve spent some time lately learning how to extend Flash Builder, and finally have some results to show.

I’ve build a few projects using the Swiz framework, which I love, but I’ve always felt that adding event handlers in the controllers was a rather tedious task, requiring a lot of checking of what’s in the event and copy pasting. So I’ve started looking into ways that I could automatize the task, and ended up learning how to extend Eclipse and Flash Builder. The plugin is very raw and still has a long way to go, but it’s doing something useful, so I’ll start using it and keep working on it. Below a quick video showing it at work.

A while ago the way to go, if you needed spell checking in Flash or Flex was Grant Skinners Spelling Plus Library (which still has a lot to offer, especially for Web applications, as it’s much smaller than the Adobe library). But, for a while now, Adobe has been working on their own project, called Squiggly, which I’m going to use.

The Squiggly library

You can download the library files from Adobe Labs. After uncompressing the .zip file you’ll find three files in the libs folder. The one you need for this tutorial is “AdobeSpellingUIEx.swc” – it’s the Flex 4 version for simple integration, so just put it in your libs folder. The “AdobeSpellingUI.swc” is what you would use if your target would be a Flex 3 application. You should use only one of them as putting both in your libs might cause troubles. The third file is used when working with more advanced options given by the library.

Getting additional dictionaries

While it’s nice to be able to spell check English words it doesn’t solve the issue for everyone. Although Adobe seems to discourage using the library with most languages, I’ve had a really good experience while using it with Polish language. So let’s take a look on how to install, and use, additional dictionaries.

First thing you need to do is get the new dictionary. There are many places that can provide you with dictionary files, I usually go to the dictionary listing on Open Office wiki ¹. There’s sometimes more than one set of files available for a given language, but what you’re looking for is usually just the spelling part, which consists of two files – one with a .aff extension and one with .dic. The rule is that the first part of the file names will be the language code, so for English spellchecker you might need “en_US.aff” and “en_US.dic” and for Polish it would be “pl_PL.aff” and “pl_PL.dic“. In my project I’m going to use both, so I’ll just put them in some directory. Here’s how it looks:

Creating a dictionary configuration file

The structure of the configuration file is fairy simple, and more ore less, only points to the files downloaded above, it’s included in the project but just for reference, here’s how to define the support for two languages.

Full project structure

Now we have all the files ready, and can start coding. Here’s how my project looks:

As you can see the project is using the new Flex SDK version named “Hero”, but it was also tested with SDK 4.1. The project downloadable at the end of this article has been created in the new version of Flash Builder “Burrito”, which includes the new SDK, and which you can download from Adobe Labs

The code

To get basic spellchecking to work you don’t need to do a whole lot. I’ll paste the whole code first, and than explain what happens.

The first thing you need to do is configure the spell checker by providing it with an XML configuration you have created. That’s what happens in the creationCompleteHandler. After that you just need to call the enableSpelling function with two parameters: first is the id of a component which should be spell checked, and the second one specifies the language which should be used. The disableSpelling function removes the spell checking, I’ve noticed you need to call it before setting a new language, otherwise it will not change. With just this few lines of code you get a fully functional spell checker. Here’s how it looks when switching languages:

If you look at code, you might also notice that the you don’t need to create a new object of class SpellUI, all the functions are static.

Final notes

A modern spell checking library would not be complete without a way to suggest proper spelling, and this also works out of the box, you just need to right click on an underlined word to get them.

But there are some things to keep in mind when starting to use this library. First, it’s still in development an a lot can change, including the way you use the library. Second, there are some issues with efficiency, the dictionaries are quite big (the Polish one is 4MB, the en_US around 600kB) and even after downloading them the parsing process freezes the application for a noticeable time. But still, a long needed addition to the Flex ecosystem is here, and it’s really easy to use.

Download source code.

The most common way to use RemoteServices in flex is by creating a separate file to keep the configuration, and adding the “-services” switch to the compiler arguments. It’s a good way to do it, but not always, and is especially painful when explaining remoting to someone. But you can skip the whole file and configure the same thing using MXML tags. I’ll take a sample “services_config” file (this one is for zend_amf) and translate it to MXML.

translates to:

So what you need to do is create a ChannelSet, put a channel inside (in this case AMFChannel) and set its uri to the one you would usually put as endpoint uri in the config file.
Once you do that you can start using your RemoteObjects without the services_config.

Of course you should add the rest of the things you usually put inside a remote object. For people who would like an example:

Yesterday I’ve started to experiment with geolocation features built into Firefox 3.5 (check here) and Chrome with Gears installed. What was ment as a Flex Cookbook post grew into a handy library. It supports both Firefox and Chrome (including the loading of the address), includes functions to check the users geolocation, track him, etc.

For the geolocation to work you need to have some javascript code in your page, the library injects the code into the DOM so that you don’t need to do it manually, for those of you who are interested how to do it here’s a cookbook post.

The project is hosted on Google Code  here, where you can also find a detailed documentation. Below you can find a sample application.

A simplest example I could think off:

As you can see the whole configuration consists of adding the library and setting the applicationID, it’s usually the same as your main class name (eg. if you create an application as App.mxml, the applicationID should be set to “App”). This is needed so that javascript in the DOM of the page can call your application with the results.

The lastResult implements the IPosition interface:

Sample (view source enabled): link