Image Markup Tool blog

Made some progress today, getting the XML declaration highlighted, and also simple XML tags. For XML tags, the simplest approach seems to be to treat the tag start (< + optional slash + tag name) as one match, and the tag closer (optional slash + &gt) as another; this allows for highlighting of the tag contents separately, and also handles the problem of multi-line opening tags (pattern matching in the syntax highlighter component is through QRegExp, which seems to work line by line).

I still haven't figured out how to get the DTD declaration to highlight (it's on two lines); it looks as though I might have to take the same approach as with comments, and I'll need to figure out how to handle two different highlighting requirements using that approach. Handling attributes and their values is going to be a bit more complicated, because I'm not sure that I can definitively say whether an att+value combination is inside a tag or not; QRegExp supports lookaheads (but not lookbehinds). Finally, one remaining problem is specifying with accuracy the XmlName pattern for tags, which I haven't bothered to do yet (I'm just using an ascii model for the moment).

I've found no good existing regexp-based code for syntax-highlighting XML (although this looks helpful), so I'm starting in on my own, by adapting the QT example app which highlights C++. I've changed library and class names, and made one change to highlight XML comments.

MB has created a package and instructions for creating self-correcting paleography exercises for students using the IMT. I've posted her materials and instructions on the site, so others can use them. The instructions are more complicated than they need to be because of a deficiency in IMT 1.x: the fact that you can't easily specify a different location for web view template files. That will be fixed in IMT 2.

I think the next phase of the project should be to write an editor widget that does XML syntax highlighting. QT has the QSyntaxHighlighter class which can do this, based on regular expressions matching each of the items that needs to be highlighted. I've spent a good while looking for an existing implementation of regular expressions to match XML elements, attributes etc., and the nearest thing I've found is this. It's enough to get us started, but I think we'll need more.

There's a good example using C++ in the QT examples folder, and the idea looks fairly straightforward, but one problem is going to be the greediness of matching, which may result in matches for opening tags which include all the way to the final closing tag. We should also think about whether we want to check the correctness of e.g. element names; W3C XML Schema Regular Expressions has support for this, and QTSyntaxHighlighter can apparently have its patternSyntax set to W3CXmlSchema11, but the effect of this is not really well documented. We'll have to proceed by trial and error.

When testing at home on a Windows 7 VM, noticed that the latest download is now QT 4.6, so I've installed that locally too. Note that you still have to manually switch the QT version in the preferences screen, otherwise your apps will presumably be compiled and running against the old version. Also found a problem with the install; in order to use QOpenGL, you need to install libglui-dev, but this won't install on my Jaunty machine because it depends on freeglut-dev, which is not available. I'm not worrying about this right now, because I'm likely to move to Lucid Lynx by May. The app compiled and ran just fine, and I found and fixed another little bug.

Added a bunch more features to the pilot application, including saving/reloading state (very simple), sanity checks in case the icon directory is not where it's expected to be, the ability to change the icon directory, an About box, and some tweaks to make for more robust cross-platform compiles. Yesterday I test-compiled on Windows 7 and everything worked.

This phase of the project can now be said to be complete. I've confirmed that all the features we were interested in are present and practical in QT, and got a feel for how to develop a basic GUI application. Progress is much faster than I expected.

Had a very heartening day today: these are the things I learned how to do:

• Create directories, copy files, etc. using platform-independent calls.
• Read an XML file using the QXmlStreamReader object (which is rather like a sophisticated SAX parser, or perhaps a nodeIterator).
• Create a DOM document and save it to disk.

XML handling looks to be really easy and practical, and my little app is now able to load and save files correctly. All that's left for the trial app phase now is to figure out how to save and restore window geometry and state, and handle enabling/disabling actions.

Moved a lot further forward towards a normal working application today. These are some of the things I learned:

• Although my data is in a QAbstractTableModel descendant, and my first instinct was to give that class a modified property to track whether the data was dirty or not, it turns out that for an SDI app like this one, you might as well store that info in the windowModified property of the QMainWindow. This makes things simpler.
• When the model's data is changed, it emits a dataChanged() signal, which I was trying for a while to hook up to a custom slot in my MainWindow. I couldn't figure out why this wasn't working. It turned out that:
  • the signal and slot must have exactly the same parameter types;
  • when you declare, you use variable names, but when you connect the signal and slot, you must leave out the variable names, and only include the ampersand;
  • omitting the const keyword will cause the connection to fail.
• QDebug is really neat and easy to use. Just include <QDebug> in the header, and call qDebug()<<"My message" to write it out to the Application Output console,

Learned a whole lot of stuff about the model/view architecture today, and finally managed to get items to be user-checkable in such a way that the user's actions are communicated back to the model. The next stage here, I think, is to clean up the code and comment the heck out of it so it can serve as a model for future similar scenarios.

Working on the pilot application using the SVG icon set I've amassed, I've made some significant progress today. I've learned how to use a QAbstractTableModel descendant to model the list of icons along with their checked states, and also to display the model through a QTreeView. The next phase is to figure out how to make their checked state editable (right now, checkboxes are displaying but not responding to clicks).