Welcome back, Editor!

Today, according to schedule, version p0.5.55 was released. It contains the new JOGL 2 library for OpenGL rendering and some MIDI playback enhancements, and after more than a year of inactivity the Zong! Editor is now buildable and runnable again.

I was a little anxious if it was hard to adapt the editor’s tools and commands to the new functional core. It turned out that it is now much easier than before to temporarily change the document’s layout for preview the user’s actions, and undo is really a one-liner:

document.setLayout(oldLayout);

Using the functional core, this can be done for nearly every command and tool, while the mutable core required lots of defensive copies and sometimes confusing undo algorithms for achieving the same thing. This is amazing, and only possible because of the great work of the pcollections project. I can really recommend having a look on this library to all Java developers. Together with a little experience gained in any functional language (like Haskell oder ML), it can (it will!) totally change the way you work with data structures in Java.

Roadmap for v0.5 development

Today I created the roadmap for Zong! version 0.5.

It will be released on 2011-09-30 and will include the following features:

  • The Zong! Editor to create, modify and playback musical scores
  • Edit all important musical notations like notes, articulations and ornaments, clefs, time signatures, key signatures, barlines, lyrics, directions and tuplets
  • Support for selections, copy & paste, undo & redo (the last one is trivial to implement thanks to the new functional core :-))
  • Create and modify instrumentations
  • Input using the mouse, keyboard or MIDI instruments (stepwise input)

During the v0.5 development process we will publish alpha versions from time to time. One of the next things is an Online Converter for MusicXML to MIDI, PDF and image formats.

Zong! 0.4 released

Yesterday, we pushed version 0.4 (aka p0.4.54) of Zong! onto our servers. From the view of a user there are not many new features compared to the alpha version released on christmas 2010, but the overall architecture has changed dramatically, as described in the blog posts during this year.

The next days we will create a detailled plan for version 0.5. We want to release a usable beta version of the Zong! Editor in October 2011. Of course, one of our main goals is also to improve MusicXML loading and musical layouting during the next months, to make Zong! a competitive viewer for MusicXML documents.

Zong! Intonation Training

As the conductor of a bavarian brass band I often have to intonate the different instruments in the orchestra. Because I found no website where you can practice your intonation hearing, I decided to write my own one and share it for free.

Here is a demo video:

[youtube=http://www.youtube.com/watch?v=l7z9XQfGbrg]

The program can be launched by clicking on the following button:

Have fun!

Swing component: Combobox for font selection

There are many great Swing components around, but we could not find a nice combobox for font selection, that includes not only the font names but also some preview characters and maybe a history of the recently selected fonts. You know such a combobox from OpenOffice.org and other word processors.

Well, here it is now. Our FontChooserComboBox offers font preview, customizable preview strings, optionally a list of the recent fonts and even auto completion for the font name. And best of all, the code is public domain, so you can use it for whatever you want. However, if you improve it, please share your work with us!

Here is a demo video:

[youtube=http://www.youtube.com/watch?v=8pOVB0jRXuA]

A webstart demo:

Here are the files:

Comments are welcome 🙂

Conducting a virtual symphony orchestra using Zong!

This blog has been quiet for the last four months. Not because the project is dead or frozen, but because I had to concentrate on my master thesis. Luckily I managed to find a topic that is related to music notation, and so I was also able to integrate Zong! into the project and bring it a little bit forward.

The project is called Pinocchio. It is a serious game that should allow young children to become acquainted with classical music by conducting a virtual symphony orchestra. The videos on the website (very outdated) give a good idea about how it works. However, as you can see, conducting was not really realistic yet and the interpretation of the gestures seemed a little bit randomly. So my task during the thesis was to extend the repertoire of conducting gestures, and introduce the ability to load and understand any piece of digital sheet music. This allows a better interpretation of the gestures, since now the context (the score) is known to the system. For displaying the score and rendering it into audio, Zong! is used in the background. It allows to open all MusicXML files, then it computes the needed information and provides it to Pinocchio.

Unfortunately, the project is not open source, and it is not finished yet. So there is no demo I can provide here, but maybe there will be some videos in the future.

Since this was my master thesis, and I needed a lot of time to do it, I had nearly no additional resources left for Zong!. This will change dramatically now 🙂 As the available prototypes show, the technology works and is still easy to extend, so now it is time to move forward to a really useable product, and of course, begin with the editor component. We will post a plan for the upcoming release here within the next days, so stay tuned!

Iteration 52 is out

The new version of Zong! contains an updated layout engine. It was not extended yet, but we cleaned up the code and gave it a more functional style. There is also a big map showing all classes involved in the layouting process:

In the next two iterations we will improve both the layout engine (features like cue and grace notes, multi-staff beams) and the MIDI output (tempo, transposition, repetitions, voltas, dynamics).

Java Tip #5: Shorter singleton calls

If you are using the Singleton pattern, you often have code like this:

Object myValue = MySingleton.getInstance().getSomeValue();

Can this be shortened? Yes! Like in Java Tip #3, we can use public static methods and static import. But then, we do not see at a glance what getInstance() is actually returning, and if we use multiple Singletons within our class, we would have a naming problem. The easy solution: rename the getInstance() method to the (camelCase) name of its class. Now we can write:

Object myValue = mySingleton().getSomeValue();

Welcome, developers!

The last days I have replaced the old, quite complex Ant build script by a much simpler configuration file written in Java, that is based on Xenoage Build, a quick & dirty extension to Ant. I did this, because I really had problems in Ant when having multiple subprojects with different dependencies on each other. I think, the lines 34 to 58 in the new config file describe this dependencies much nicer than the old Ant script.

Additionally, I have added a tiny tutorial how to set up Zong! in Eclipse. Following these three steps, you can run and debug Zong! within two minutes on any operating system.

Developers are welcome! If there are other things we can do for you, please don’t hesitate to tell us what you need.

Iteration 51 is out

After many weeks of work, Zong! p0.4.51 is finally out. Although there are no new features which are interesting from a user’s perspective, there are two important changes which are essential for the future development of the project:

  • The core has been completely replaced. While it was based on mutable Java classes and operations using many side effects before, the core is now completely functional. It is now much easier to test and maintain, and undo/redo is now a trivial task. The new core wouldn’t be possible without the excellent work of the pcollections project, which I can really recommend for Java projects of any kind.
  • The musicxml project replaces proxymusic. While this is also a great library which I can recommend to all Java+MusicXML projects, we had problems with the Reflection techniques it is using (applets must be signed then), JAXB’s not-so-optimal XML-to-Java conversion and its speed (on my machine proxymusic needs about 2 minutes to load all official MusicXML 1.1 and MusicXML 2.0 samples, while our new musicxml library needs about 5 seconds). The two projects do basically the same, but proxymusic is automatically generated from the MusicXML schema, while our library is written by hand, which is really a very boring task, but finally it was worthwhile.

The goal for the next iterations is to rewrite the layout engine so that it fits to the functional core. Then, we can continue to improve the layout engine and support more music notation features. We also plan to offer a web service that converts MusicXML to PDF (and possibly other formats).