Professional Development

Took delivery of a camcorder. Did some testing. Most pleased with results.

Shoots 1920x1080, comes with dock and much cabling. Looks like it isn't really happy with panning - probably a result of running it at 60 fields/sec. Running it at full res, but 30 frames/sec seems to be better - not perfect, but much better. Martin suggested that it's the CCD that can't keep up. Quite possible, given the price of the camera; CCDs are expensive, the camera wasn't.

Full res panning/zooming - in fact any kind of movement - creates very jittery results. I found several sets of plans online for building your own steadycam, but I like these best. I'll try to build one at home. If it works out I'll bill for hours/materials.

Editing the video couldn't be easier. The camera produces H.264 video in an mpg container that just works. Mount the device as a volume on your machine, browse volume to the file you want, drag it to desktop, import/move/copy file in to Final Cut/iMovie and you're ready to edit. Haven't tried it on Linux/Windows yet, though I expect it to be just as easy - as long as I can find an editor for those platforms that handles MPEG-4 natively.

I'm looking at the possibility of moving away from Delphi over to Trolltech's QT platform for desktop application development, so I've spent while looking into their documentation and licensing. While it seems QT is absolutely everything we need (built-in Unicode, scripting, great widgets, cross-platform, WebKit and ECMAScript integration, SVG support, etc.), there are some serious drawbacks. One is that I'd need to learn C++, but actually that might be interesting and a good investment from the Pro-D point of view. The other drawback is that, while you can use QT for open-source development under the GPL, and you're allowed to MPL your code if you want, you can't (they say) then move that code to commercial projects; and the commercial licensing is flat-out prohibitive ($6600 US for one developer working on the three platforms). That would pretty much preclude our commercializing one of our HCMC projects (as we previously did with HotPot and Quandary), which would be a real shame.

So I'm still thinking. The platform looks SO inviting, but the price is almost insane. They obviously don't want small-scale or low-profit developers (such as the educational software crowd) to consider the platform at all as a commercial proposition.

The next version of Firefox, currently in Alpha 2, has some fabulous new features, including integrated video support (HTML 5) and presumably audio as well. We need to get working with this to do some bug reporting and find out how it can help us avoid (e.g.) Flash in future. I've got it installed on a VM, because it's pretty unstable, and doing that involved updating the VM twice, but once that's all squared away we can start creating some test materials to find out what it can actually do. (For instance, does it have some codecs built in, and if so, which are they? Can it use any codecs on your machine?)

Installed the new NetBeans 6.0 and tested my current projects with it. Seems fine -- several improvements over 5.5.1.

In a number of my applications, mainly IMT and Markin, I've been building a large library of interface icons based on the Nuvola GUI icons. All of them are in SVG format, and for Delphi use, I convert each one into 12 different BMP files, for three states (normal, hot, disabled) and four sizes (16, 24, 32, 48). These would be very useful for our Java GUI apps, but they need to be in transparent PNG formats, so I began investigating how best to do the conversions. I do my Delphi conversions using a script I wrote in the GIMP, one image at a time. However, for the entire library, which is now 145 images, that would be very tedious, and it would help to have a conversion tool which could later be adapted to provide other formats where required.

I started by learning that Inkscape has basic command-line functionality which enables me to load an SVG file and convert it to another size. I decided to call this functionality from a simple Delphi app, to give me more flexibility than batch files will provide. Having got the Delphi app to create PNGs at all four sizes, the next stage was to figure out how to create the disabled and hot images. At first, I thought ImageMagick would be the solution to this. I discovered that IM can do the lightening needed to produce a "hot" image like this:

convert  minor.jpg   -sigmoidal-contrast 4,0%   minor_04.jpg

Next, I began to look for ways to produce the grayscale disabled images. IM can do this, too:

convert  test.png  -modulate 100,0  grey_brightness.png

These examples come from this excellent site.

So ImageMagick looks like the best tool to do the conversions. Initially, I decided it would be simplest to make copies of all the existing images in the hot and disabled folders, and then process those in-place. After some hacking around, I found I could only get Delphi to do that by using XCOPY instead of COPY. That's now working. I'm now reconsidering that approach, though, and I think it might be simpler to go through each of the images in each of the size folders, and create output hot and disabled images in their appropriate folders. using ImageMagick. That's for anotehr day -- ran out of time today.

Once this is done, I'll need to look at ways to assign images to actions in Java apps in an efficient and centralized way, as I'm able to do in Delphi, and figure out how Java might be able to use disabled and hot images as well as normal ones.

Revisiting my Apparatus app, I hooked it into the preferences object, and tried adding support for JFileChooser. This proved more complicated than I expected, because the JFileChoosers are usually created on the fly, so they're not owned by any other component in the hierarchy; they're just instance variables in the JFrame class. We had to use some reflection code to iterate through all the variables in the class to find any which are JFileChoosers. In order to make this work, they have to be public rather than private, but that's not a big deal.

As part of the teiJournal project, I needed to write a simple text-transformer that would turn CSS rulesets into XSLT attribute-sets (documented on that blog). I decided to do this in Java to get more practice with basic apps, and take advantage of the opportunity to abstract more of the code I learned writing the Apparatus app into general-purpose utility classes.

I created a class called MdhPrefs in ca.uvic.hcmc.utils. The purpose of this class is to save and reload a range of key info for a JFrame descendant, so that the JFrame can initialize an instance of the object when it starts up (after initComponents() is called) and get preferences for a wide range of settings loaded automatically.

How to use it:

1. Create a private variable in the JFrame descendant class:

   private MdhPrefs mdhPrefs;

2. Initialize it after initComponents() is called in the class's constructor:

   mdhPrefs = new MdhPrefs(this);

3. In the JFrame descendant's formWindowClosing event, make a call to save the data:

   mdhPrefs.saveData();

At the moment, this class saves only window size and position, and the position of any splitter bars, but it will be extended to include a lot more information. The load/save code is recursive, so it should catch all components which are descendants of the JFrame.

This kind of reflection looks to be very powerful; it's similar to the code I've written in the past for Delphi, but (so far) a bit cleaner, because the component hierarchies seem more straightforward. A set of classes for translating the interface could be created in the same way.

I abstracted generally-useful routines such as file loading/saving and resource loading into a new package called ca.uvic.hcmc.utils.

Also, with Stew, took a close look at JGoodies, and ran some of the demos. You could write a seriously attractive GUI with this stuff, and it's BSD-licensed in a very open manner so it could be used in commercial code too.

After writing a little application in NetBeans to process Devonshire MS collation data into TEI format, I'm continuing my Java education by learning a few more things that aren't strictly relevant to that project. With Cocoon, eXist and Juxta written in Java, it makes sense to develop skills in this area, and with Java 1.6 and the latest NetBeans IDE, the tools are now mature and the platform is pretty solid.

Today I was learning how to manipulate resources such as images as part of the application. In the IDE, and when running the app in its debugger, there seems to be no actual JAR file, so images can only be loaded from the file system; however, when you build the JAR, any images are bundled into the JAR, and then you need to use different code to get at them. In order to have an app that runs correctly in the IDE and as a JAR file, therefore, you need to allow for both contingencies, so I have code that looks like this:

File iFile = new File("images/smiley.png");
        if (iFile.exists()){
            setIconImage(new ImageIcon("images/smiley.png").getImage());
        }
        else{
            setIconImage(new ImageIcon(getClass().getResource("images/smiley.png")).getImage());
        }

to set the icon for the application's main form.

I've also been researching the possibility of using SVG images instead of regular bitmaps as application widget icons (on toolbars etc.). This project makes use of Batik to render SVG images in a scalable fashion in a Java UI. This is really worth looking at. Right now, my Windows apps use 12 different versions of each glyph image to allow four sizes and three states; this system might allow me to use just one image, and let the user scale it exactly how they like.