FlexBuilder may have its ups and downs but it still remains my pick for best AS3/MXML editor on the market (with TextMate not far behind). Part of the beauty of FlexBuilder is that it’s built on the Eclipse SDK, one of the most versatile and powerful IDEs available, which is not only free and open source, but boasts a wealth of third party plug-ins for every kind of (mostly Java) development. This article will take a look at some must-have plug-ins for doing Flex development as well as some tips for tricking out your development process.

As with all of our entries, your feedback, suggestions, corrections and additions are all more than welcome.

(more…)

AIR public beta is out.

and while you’re at it…

Flash Lite 3

New Flash Player

and BlazeDS, whatever that is. (Hint: despite the name, this is not Flash CS3 for Gameboy)

Aviary is a platform ecosystem for people who create. It is organized around a suite of Flex-based rich internet applications geared for artists of all genres. From image editing to typography to music to 3D to video, we have a tool for everything.

Sign up on the site for an early preview invitation. These tools, if not truly competition for CS3, at least look very interesting on the surface. It’s hard to imagine developing so many tools at once.

One of the most important new features in Apollo is the ability to access the local file system directly. This provides developers with the ability to read and edit text or html files, save preferences locally, store application states as external files, serialize and de-serialize data and much more. This tutorial will cover the File API features in Apollo step-by-step and will serve as a supplement to the talk I recently gave at the New York Flex Users Group.

This tutorial will be presented in multiple sections. This first will cover the File and FileStream classes and the subsequent ones will cover the Flex components used for viewing and accessing the file system and serializing and de-serializing data.

(more…)

Hi. For you readers in NYC, I’ll be speaking at the next NY Flex Users Group on the Apollo Filesystem API. I hope you can make it! If not, watch this space for notes and code samples. Cheers!

NYFLEX.org

I’m pleased to announce the first alpha release of ApolloMail, a cross-platform POP3 / SMTP e-mail client written in Apollo (obviously) in under 500K (and most of that is my gratuitous about banner). It’s just the beginnings, really, but here is a short feature matrix:

• Authenticated POP3
• Authenticated SMTP
• MIME multipart emails
• HTML e-mail rendering
• Image attachments
• Base64 decoding
• Quoted-printable decoding

Features that may be added very soon are:

• Local message store
• HTML e-mail composing
• Rich Text rendering
• Better attachment handling
• Far more robustness

IMAP and SSL are less likely to be added soon. I would like to also use this as a platform to do something new with email, including several unique views which visualize your e-mail life graphically and in three dimensions. Otherwise it’s just another boring e-mail client.

E-mail has been around since 1971 (that’s ten years longer than me!), and it’s been built upon time and time again. I learned a ton about how e-mail works by building this app. On the other hand, I am sure I haven’t covered every kind of e-mail, POP server, or SMTP server; chances are fairly good you will come across an e-mail that this client doesn’t handle. Don’t panic It’s just an alpha. In addition to mail rendering, the error handling while communicating to the server could be better. If you are experiencing trouble, watch the Activity window. Further, the windowing built into this version of Apollo is a hack, so many Flex components don’t work correctly.

There are a number of interesting technologies in Apollo that this app takes advantage of, which I will be sharing all of in the coming days. First, it leverages my windowing framework which I discussed in a bit of depth before. It logs to a file using the File Logging Target I published earlier. It also uses another simple but awesome technique to implement the activity window — a String logger which exposes its cumulative log messages as a bindable variable — so the activity window is a TextArea bound to a log target which filters only a specific category of logging information (while all logs are saved to disk). It extends an abstract preferences class which makes it a snap to bind to, serialize and deserialize application preferences to disk. And of course, it makes heavy use of binary sockets and regular expressions made possible by Flash Player 9.

I’ll be writing more about the technology involved, and sharing more of the source, in another post or two. For now, grab the Apollo runtime if you need it (link has mandatory registration), and take ApolloMail for a spin! Cheers!

Update: This application is made for the Apollo Alpha. If you have the AIR Beta runtime, it will not work. The next version of ApolloMail will be upgraded for this release of the runtime.

ApolloMail (ZIP, 486k, ZIP decompresses to an AIR file, open the AIR file after installing the Apollo Runtime.)

Well, I don’t know why this wasn’t included with Apollo, but it was certainly easy enough to add in. :) I created com.partlyhuman.apollo.logging.FileTarget so you can use the Flex logging framework while logging to a file. It supports all the options of TraceTarget (livedocs), and you can also (optionally) specify a custom filename to log to, or force it to append log output across sesssions.

Here’s how you might put in a file logging target in MXML:

<logging:FileTarget
	filename="error.log"
	append="false"
	level="{LogEventLevel.ERROR}"
	includeDate="true"
	includeTime="true"
	includeCategory="true"
	includeLevel="true"/>

That’s showing off a lot of the options. You could just do <logging:FileTarget/> and all would be fine. And if you haven’t checked out logging in Flex, it’s pretty nice (livedocs). All logging events have a category, so you get a logger for that category then call the appropriate level on it, or call log with the level as an argument. For example:

Log.getLogger("com.partlyhuman.demoapp.MainController").error("initialization failed!");
Log.getLogger("com.partlyhuman.demoapp.Bubble").info("bubble popped!");

You don’t have to be so verbose in your categories, but that’s one way to use it.

This is gonna totally become like, a thing, but… happy logging!

com.partlyhuman.apollo.FileTarget View Source | Download (.as, 3k)

Application windows are windows that can always be brought up, like an activity window, or an about window. When you create an application window, it is created and hidden. Pressing the close button on the window is captured to hide the window rather than allowing it to be destroyed. Thus, it occupies a permanent position on the Window menu.

Document windows are windows which can be created and destroyed. You can have many instances of the same view class. These are useful for new mails or text files or what-have-you.

The main window has a special use. When you attempt to close it, it attempts to close all the child windows as well — so you can have an opportunity to save your unfinished document windows.

This is the windowing toolkit at work on an Apollo app I’m finishing up now. File→New Mail… creates a new document window with the compose view, and adds it to the Window menu. As you change the subject, the title of the window and its name in the Window menu are updated. The Window menu also permanently has several application-wide windows which the close button appears to close. The Window menu brings them and any other window back, even if they are minimized, hidden, or stacked on the bottom.

After the cut, let’s take a look at how this is set up in code.

(more…)

I’m developing a window manager to make things much easier for Apollo apps. The full window manager will be up shortly. For now, I have created a simple window manager, that wraps up the many steps necessary to create a window containing a Flex view (and clean it up on destruction!) into a really simple singleton class. The more fully-featured window manager will use this class, but it can be very helpful on its own. It makes creating new windows with Flex views a one-line operation:

var aboutWin:NativeWindow = WindowManagerSimple.getInstance().newWindow(AboutView, "About", {maximizable: false, resizable: false}, 300, 100);

You can use either a class name or a UIComponent instance for the view, and all the other parameters are optional. The window options parameter can accept a NativeWindowInitOptions object or an anonymous object of properties that override the defaults for brevity. See the source file for more info, Javadoc-styleeeee.

Next: A more complete window manager, including application and document windows. Read on.

com.partlyhuman.apollo.WindowManagerSimple View Source | Download (.ZIP, 6K)

At least mine eyes did not deceive me about the other feature I really am looking forward to, native menu bar support. This is more of an issue for the Mac platform since menus are already grouped with the main application window in Windoze.

So these two limitations kind of throw a wrench in what I was trying to do… I guess I’ll do the Windows 3.1 thing and have one big window with a window-docked menu, and containing the document windows as children. The document windows and menu will both be standard flex components within the main Apollo window. Anyway, I’m looking forward to the next public alpha rev! Hopefully it’s on its way :)

Update: I was thankfully wrong about cross window applications, even in the alpha. Adding Flex components requires a pretty straightforward workaround. Daniel Dura’s approach. Todd Anderson’s approach. Ask (a stupid question) and ye shall receive (an answer from the internets)!

Update: Native window saga part two, part three.