jkt's blog

It's my pleasure to announce that version v0.3 of Trojitá, a fast and lightweight IMAP e-mail client based on the Qt library, is now available. For more details of what Trojitá is and who should use it, please see below.

(Permanent link to this announcement.)

Changes since version v0.2.9.4

This release is a major one, bringing new features, plenty of bugfixes and two new contributors to the table. A quick summary of what has happened:

• Drastic reduction in memory usage
• Tagging e-mails (contributed by Shanti Bouchez)
• Faster fetching of data
• Much more efficient support for threading
• More robust IMAP support
• A new Debug menu
• Autocompletion of e-mail addresses (contributed by Thomas Gahr)
• Reporting server/client configuration through ID
• Support of multipart/related for full rfc2387 compliance
• Showing Trojita's homepage on start
• GUI fixes (now finally works in dark themes)
• SMTP works over SSL (contributed by Shanti Bouchez)
• Expanded unit test coverage
• Plenty of bugfixes and further improvements

What is Trojitá

Trojitá is a very fast and lightweight IMAP e-mail client written using the Qt library.

What could make Trojitá interesting for you

• It's a pure Qt4 application with no additional dependencies; it builds in two-and-half minutes on a five-year-old laptop
• Robust IMAP core implemented using Qt's Model-View framework
• Standards compliance is a design goal
• On-demand message list and body part loading ("lazy loading")
• Offline IMAP support
• Support for bandwidth-saving mode aimed at mobile users with expensive connection
• IMAP over SSH -- instead of going over an SSL socket, the server could be accessed via SSH
• Safe and robust dealing with HTML mail

Please note that the "message sending" and "message composing" features of Trojitá are a bit lagging at this point and therefore it is not recommended to use Trojitá for these tasks apart from testing.

Certain features of Trojitá depend on the IMAP server's functionality. Trojitá is written from the bottom-up as an IMAP client and is designed around its feature set. For example, threaded message viewing (ie. "conversations") is supported only if the server implements an appropriate extension for now.

Trojitá is under heavy development, features are added on almost daily basis and the codebase is rapidly maturing. Certain useful features are still missing, there is no support for searching, for example. We have tickets opened for these, so please Cc yourself at the task tracker if you would like to follow the progress here.

Finally, as with any software, Trojitá has some bugs which are already known and reported in the issue tracker and some which are still waiting for discovery. That said, it is safe to use to for *reading* mail. I've been doing that for several years on a production account, and I have never lost a mail with Trojitá. Please do not send e-mails with current version, though, as it is known to produce non-standard messages in certain circumstances.

Where I can get it

Our web has all the required information, but if you are impatient and just want to grab the tarball for v0.3, download from Sourceforge:

http://sourceforge.net/projects/trojita/files/src/trojita-0.3.tar.bz2/download

Trojitá is known to work on Linux, Mac OS X and Windows. It should also run on all platforms supported by Qt. A MeeGo version is still pending, though.

Reporting bugs and wishes

Please use the Redmine portal to report issues with Trojitá. If you do not want to be bothered by a registration, please at least send bug reports via e-mail or report them at the #trojita IRC channel on Freenode.

Community

Trojita could always use more people in the community. Areas in which people are needed most, as well as general guidelines about how we prefer to work are documented at the wiki.

The IRC channel is #trojita on irc.freenode.net, the mailing list is trojita@lists.flaska.net (moderation required for non-subscribers, archived at various places etc).

Acknowledgment

A huge thank you goes to two new contributors who have submitted patches to make Trojitá better. It's my please to introduce Shanti Bouchez who is responsible for the new feature of tagging messages (and fixed STARTTLS for SMTP subscription in the process, among other things). The second contributor is Thomas Gahr who added e-mail auto-completion and fixed bugs.

Since its inception in 2006, many other people have contributed to Trojitá as well. I'd like to mention patches from Benson Tsai, John Rogelstad, Andrew Brouwers, Gil Moskowitz, Jiří Helebrant, Jun Yang, Justin J, and Tomáš Kouba, who have all sent patches in. Finally, another huge thank you goes to anyone who has reported bugs or helped make Trojitá better in any way.

Cheers,
Jan

I'd like to let you know that I've succeeded in building Trojitá for MeeGo 1.2 Harmattan, as available on the Nokia N950. It is completely unusable for now due to the lack of a real mouse, but shows pretty nice that it *can* work :). A screenshot:

So, now that I know that the port actually builds and that the device can run my code, I'll plunge into the QML world and create a proper touch-friendly GUI. I'll keep you posted about my progress.

I'd like to say a huge thank you to Nokia and its Developer Launchpad team, especially those that are responsible for the Community Device program. Nokia was kind enough to offer a loan of the N950 at no charge for the purposes of Trojitá development, and I really appreciate it.

Cheers,
Jan

I was thinking that it might be a good idea to share my view on how Trojitá is going on, and what my plans for its future are. For a quick overview of Trojitá, a fast and lightweight IMAP client, please look at the project homepage or see the FAQ.

So, with version 0.2.9.3 out (what a nice number, isn't it?), it's time to take a look at what needs to be done before people can actually use Trojita on a daily basis. For my use case, the following is really lacking:

• The mail composer just sucks. It sucks in quite a few ways, from simple stuff like using proportional font (fixed yesterday) to mangling of all addresses which go through the widget or not saving the resulting message anywhere. It needs attention.
• Reply function, with proper quoting.
• Quick search through messages in the current mailbox. I often need to find a particular message, and simply typing a part of its subject, or a sender or recipient, is what I use most often. A full-blown multi-mailbox search is probably not needed at this point, but a basic, quick input box for searching would be very much welcome.

There are many more issues, both major and minor, and I've filed some of them at the roadmap for Trojitá 0.3 in Redmine. It's very likely that I forgot to mention something, so please, feel free to submit issues and/or comment on what is the biggest blocker for you.

I'm really looking forward to hearing from you, so if you have a minute and this post caught your interest, get Trojitá and write a mail to tell us what is lacking.

All the best,
Jan

It's my pleasure to announce that version v0.2.9 of Trojitá, a fast and lightweight IMAP e-mail client based on the Qt library, is now available. For more details of what Trojitá is and who should use it, please see below.

Most of the changes in this version happened under the hood, but there is a bunch of user-facing improvements -- the most prominent one is probably the support for display of message threading (ie. "conversations").

(Permanent link to this announcement.)

Changes since version v0.2

• Refactored core IMAP code with safer command pipelining and increased robustness
• Message threading (aka "conversations") in the message list
• Plenty of bug fixes and GUI tweaks
• Improved unit test coverage
• Internal changes allowing making new UI frontends easier
• First real-world application of Trojitá in a library-like fashion

Sadly, the Maemo version which first appeared as a beta during fall of 2010 could not be merged into the main repository before this release, but you should stay tuned for future updates.

xTuple integration

Trojitá is going to be featured as an addon for the xTuple business management software. Using Trojitá will enable xTuple customers to integrate e-mail messaging into their ERP systems. Please note that xTuple users should use packages provided by their vendor and not this source version.

What is Trojitá

Trojitá is a very fast and lightweight IMAP e-mail client written using the Qt library. While it is not intended for use as a regular e-mail client just yet, it could be interesting to play with it to see if the speed looks compelling to you.

What could make Trojitá interesting for you:

• It's a pure Qt4 application with no additional dependencies; it builds in two-and-half minutes on a five-year-old laptop
• Robust IMAP core implemented using Qt's Model-View framework
• Standards compliance is a design goal
• On-demand message list and body part loading ("lazy loading")
• Offline IMAP support
• Support for bandwidth-saving mode aimed at mobile users with expensive connection
• IMAP over SSH -- instead of going over an SSL socket, the server could be accessed via SSH
• Safe and robust dealing with HTML mail

Please note that the "message sending" and "message composing" features of Trojitá are a bit lagging at this point and therefore it is not recommended to use Trojitá for these tasks apart from testing.

Certain features of Trojitá depend on the IMAP server's functionality. Trojitá is written from the bottom-up as an IMAP client and is designed around its feature set. For example, threaded message viewing (ie. "conversations") is supported only if the server implements an appropriate extension for now.

Many of the optional IMAP features are not utilized at this point; there is no support for searching, for example. We have tickets opened for these, so please Cc yourself at the task tracker if you would like to follow the progress here.

Finally, as with any software, Trojitá has some bugs which are already known and reported in the issue tracker and some which are still waiting for discovery. That said, it should be safe to use to for *reading* mail. I've been doing that for several years on a production account, and I have never lost a mail with Trojitá. Please do not send e-mails with current version, though, as it is known to produce non-standard messages in certain circumstances.

Where I can get it

Our web has all the required information, but if you are impatient and just want to grab the tarball for v0.2.9, download from Sourceforge:

http://sourceforge.net/projects/trojita/files/src/trojita-0.2.9.tar.bz2/download

Trojitá is known to work on Linux, Mac OS X and Windows. It should also run on all platforms supported by Qt. Optimizations for mobile devices and the Maemo/MeeGo are in the works.

Reporting bugs and wishes

Please use the Redmine portal to report issues with Trojitá. If you do not want to be bothered by a registration, please at least send bug reports via e-mail or report them at the #trojita IRC channel on Freenode.

Community

Trojita could always use more people in the community. Areas in which people are needed most, as well as general guidelines about how we prefer to work are documented at Contributing to Trojitá.

The IRC channel is #trojita on irc.freenode.net, the mailing list is trojita@lists.flaska.net (moderation required for non-subscribers, archived at various places etc).

Acknowledgment

I'd like to thank the KWest GmbH. and OpenMFG LLC, dba xTuple for their support in delivering the exciting new features of Trojitá. Another acknowledgment goes to the helpful folks at the #qt IRC channel and the qt-interest mailing list and also to everybody who reported an issue with Trojita or tested it against another IMAP server.

All the best,
Jan

Today, on the 3rd day of the month, 333 days since the initial announcement, it's my pleasure to announce the immediate availability of a new release of Trojitá, a Qt IMAP e-mail client. This is a technical preview release not designed for production use, but rather a demonstration about what's been done in the past months. It should be safe to point it to your production IMAP server (it has never eaten any mail for me), but one shouldn't send real e-mails or otherwise rely on it apart from testing.

New features in this release include:

• Much improved offline support with proper on-disk caching
• Tons of bugfixes (and I really mean it -- there have been plenty of them)
• Improved interoperability with various IMAP servers, including Microsoft Exchange
• Parallel connections to the IMAP server for increased performance when dealing with multiple mailboxes
• Improved connection handling, asynchronous operation and robustness, much more detailed error reporting
• IMAP protocol log
• Click-to-show external entities from HTML e-mail
• GUI tweaks
• The build system now uses QMake instead of CMake for better integration with Nokia's building infrastructure and embedded deployments
• Trojita now builds and runs on Windows and Maemo5 (Nokia N900 -- stay tuned for more news)
• Unit test coverage got expanded

If you are interested, you can download Trojitá 0.2 now. There's also a GPG signature of the release. The same contents is available in the GIT repository under the v0.2 tag.

I'd like to use this opportunity to thank KWest for their support which tremendously accelerated Trojitá's development.

I've spent more than 10 hours in total changing the build system of Trojitá from CMake to QMake upon a request from KWest. The process was very painful for me, so I think it's worthwhile to include some comments about what were the major obstacles.

The first step, "getting the beast to build", was actually pretty easy -- I (KWest actually) simply created a list of all files in the tree, added them into a single .pro file, removed the #includes for MOC, commented out the unit tests and rebuilt the project. That was the easy part; qmake simply built bunch of .o files and linked them together.

Problem with unit tests is that they all define the main() function. Therefore, as far as I know, one has to create a separate .pro file for each unit test, use the template = subdirs and put each test into a subdirectory. That's slightly annoying when compared to CTest (see the Trojita's git repository for how the CMakeLists.txt looked before we switched), but doable and actually pretty straightforward. Now, a much bigger problem is persuading QMake to create static libraries and using them properly and in a cross-platform way. I care about the Unix platform, some users want to play with Trojita on Windows, and there's that secret device KWest is building.

Trojita currently consists of several parts; we have the core IMAP stuff (which itself consists of three or four components), the GUI layer, some third-party modules even (like Witold Wysota's qwwsmtpclient, the Qt's iconloader, a unifying layer for QProcess and QSslSocket etc). The unit tests for the IMAP protocol clearly should not care about icons at all and shall ignore GUI classes, too, but they do need to link against the IMAP protocol implementation. A reasonable way to express that in the build system is to create a static library for the IMAP stuff and link it to the rest of the GUI when building the application and to each of the unit tests when building tests. That's where problems with QMake start to hurt.

Unlike CMake, under which the static libraries are extremely easy to write, QMake's support and documentation for static libraries leaves much to be desired. A reasonable request is, for example, expecting the build system to isolate me from stuff like library placement -- I just want to tell it that I need to link against bunch of .arelease and debug when caring about Windows builds.

Another expectation is that QMake should relink each binary if any static library it depends on gets rebuilt. Too bad, using QMake, you have to include the library name in three places for this to happen: at first, you have to use LIBS += -Lpath/to/your/lib/directory, then you got to actually link to it by LIBS += -lnameOfTheLibrary, and finally you have to take care of the rebuilding by PRE_TARGETDEPS += full/path/and/the/libIdentifier.a. Oh, and please do not forget about CONFIG += ordered, or the PRE_TARGETDEPS won't affect much stuff anyway. Yuck!

There's the CONFIG += create_prl and CONFIG += link_prl, but they did not help me. I guess they are used for specifying dynamic libraries on which the currently processed static library depends. They certainly did not fix my problems when I played with them, though.

Anyway, this is what I ended up with:

---

Project file for the GUI stuff, src/Gui/Gui.pro:

(...)

trojita_libs = Imap/Model Imap/Parser Imap/Network MSA Streams iconloader qwwsmtpclient

myprefix = ../
include(../linking.pri)

---

Each of tests/test_*.pro:

TARGET = test_Imap_LowLevelParser
include(../tests.pri)

---

A helper file for unit tests, tests/tests.pri:

QT += core network
CONFIG += qtestlib no_lflags_merge
DEFINES -= QT3_SUPPORT
DEPENDPATH += ../../src/
INCLUDEPATH += ../../src/ ../
TEMPLATE = app
HEADERS += ../qtest_kde.h


trojita_libs = Imap/Parser Imap/Model Imap/Parser Streams
myprefix = ../../src/
include(../src/linking.pri)

SOURCES += $$join(TARGET,,,.cpp)
HEADERS += $$join(TARGET,,,.h)

---

And finally, the file, src/linking.pri:

for(what, trojita_libs) {
    mylib = $$replace(what,/,)
    unix {
        mypath = $$join(what,,$${myprefix},)
    }
    win32 {
        CONFIG( debug, debug|release ) {
            mypath = $$join(what,,$${myprefix},/debug)
        } else {
            mypath = $$join(what,,$${myprefix},/release)
        }
    }
    LIBS += $$join(mypath,,-L,)
    LIBS += $$join(mylib,,-l,)
    PRE_TARGETDEPS += $$join(mypath,,,$$join(mylib,,/lib,.a))
}

---

Compare the above to the elegance of CMake, depicted below out of sentiment:

set(libImap_SRCS
    ${CMAKE_CURRENT_SOURCE_DIR}/Imap/Parser/Parser.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/Imap/Parser/Command.cpp
...
)
...
add_library(Imap ${libImap_SRCS})
...
target_link_libraries(Imap Streams ${QT_QTGUI_LIBRARY} ${QT_QTCORE_LIBRARY})
...
target_link_libraries(trojita Imap MessageView ModelTest MSA QwwSmtpClient QtIconLoader)

That's what I call ease of use. Anyway, the QMake change just had to be done (when the customer asked if I could migrate to QMake, I said I had no preference) and it's been done now. This blog post is just a rant, and hopefully might eventually make its way to Google's results for "qmake static library".

There's always the possibility that I'm just too dumb to miss a completely obvious way to work with static libraries in QMake. If that's indeed the case, I sincerely apologise to QMake designers. Also, I offer one beer as a sign of appreciation to the first person who shows me that I'm indeed missing something from the big picture. In the meanwhile, have fun -- QMake has a lot of nice features and I'm no longer afraid to use it, now that the static libraries are used properly. The make test is still missing, but I guess I can live without that for a while.

This weekend I had the pleasure of travelling to a beautiful city of Schlitz. After some six hours on train, I arrived to KWest GmbH, a cool company which specializes in manufacturing of embedded systems, and which is nowadays busy developing an Internet tablet for a German ISP. It turned out that the company likes Qt and free software and is not particularly happy with the availability of Qt-based IMAP clients. As it happens, I was not happy with the world of IMAP clients, either, and I chose that as a subject for my bachelor's thesis a few years ago.

After having met KWest's representatives, we came to conclusion that Trojita is indeed a suitable IMAP e-mail client for them, and that while they do have a skilled development team, it would be beneficial for both me and them to work together. We have agreed that they will focus on bringing the GUI of the application up to speed with modern standards, adding important features like address book and a decent platform integration to the mix, while I will focus on what I'm good at, that is, improving the IMAP support, especially the offline mode.

The good thing for the community is that Trojita will remain under the GPL and that I'll be able to spend much more time on its development. Given enough time, Trojita will mature, and if everything works well, we will see a nice Qt e-mail application pretty soon. As usually, both the bug tracker and all source code remains freely available without any restrictions.

I'd like to thank KWest GmbH for giving me an opportunity to work on a free software project that I'm interested in, especially to Sebastian for inviting me and to Markus for being a nice guy to work with. And if you have some spare time and are looking for a nice little city to visit, be sure to stop in Fulda and Schlitz, their city centers look as if they came straight from a fairytale.

History

When I looked at the state of graphical IMAP e-mail clients several years ago, I was not really impressed. KMail from then-current KDE3 did not do a proper job for me (numerous IMAP bugs like its inability to work as about every other IMAP client when deleting messages, bug 26986 -- there were more issues than that, but years have left my memories washed out a bit), Thunderbird would crash for me every once a week, at least, and I just happened to like KDE applications more than Gnome stuff, so I did not spend much time looking at Evolution. Many MUAs looked like a classic generic e-mail clients designed with POP3 in mind with IMAP added late in the development cycle, while others supported wide range of IMAP features, yet lacked in the GUI part of the problem. In short, using none of these applications made me feel happy.

A programmer not feeling happy is a receipt for disaster. I was about to finish my high school, so I had plenty of time at hand. I was experimenting with Python, so that seemed like a natural implementation language, too. In the end, I started a project called trojita whose remnants could still be seen in an abandoned SVN repo.

Coding in Python was fun. I tried several different approaches to the design of my pet program, I was playing with technologies I had no experience with, I even showed my "IMAP library" at my final exam as an example of a project I made. It did not have much functionality, in fact, only the IMAP parser had been completed, but it was an educative experience nonetheless and I passed the exam.

After some time, however, I discovered Qt and C++ and felt in love. I joyfully returned to the realm of statically-typed languages and suddenly felt a lot better. I began porting my Python library to Qt/C++. It was not really a port, rather a first complete rewrite of my project. Anyway, it did not take long and the C++ version suddenly offered more functions than the old Python branch, with unit tests as a nice added bonus.

Qt's Interview architecture, the Model/View classes, seemed like a decent implementation of the MVC patter I was poking around to use. Several months have passed, and suddenly trojita was able to show a tree of mailboxes stored on a remote IMAP server, listing messages contained therein and showing message bodies. I choose to finish the program as a part of my bachelor's thesis, and ultimately, I succeeded.

The Code

So, in a few blogposts starting with this one I'm going to introduce a new Qt IMAP e-mail client to the world. I hope I will get some attention and folks looking at the code and trying to run the application. I'd love to get some feedback on program design, code quality and general usability as well.

The code is hosted at Gitorious, and a bachelor thesis about Trojitá (PDF) (mirror) which explains its design and compares it against several alternatives is available, too. Perhaps the most interesting part is Chapter 3 which describes the architecture of the application, and Chapter 4 in which I compare Trojitá to several other MUAs on the market. All information about Trojitá are also aggregated on Trojitá's homepage (any web designer listening? :) ). Here is the obligatory screenshot:

Trojitá's Features

Some highlights of Trojitá are:

• A pure Qt4 application with no additional dependencies
• Robust IMAP core implemented using Qt's Model-View framework
• Standards compliance is a design goal
• Support for bandwidth-saving mode aimed at mobile users with expensive connection
• IMAP over SSH -- instead of going over an SSL socket, the server could be accessed via SSH
• On-demand body part loading
• Offline IMAP support (you can access data you already have; there's no complete "offline mail access" yet, though)
• Safe dealing with HTML mail (actually more robust than Thunderbird's)

The thesis was completed several months ago. Since that time, I've removed the dependency on std::tr1::shared_ptr and switched to Qt's QSharedPointer which in turn requires Qt-4.5 or newer. There wasn't much more changes since then, as I enjoyed quite a long vacation, but I guess I can tell the development is getting faster again.

How to Use it

It's a fairly standard CMake setup:

git clone git://gitorious.org/trojita/trojita.git
cd trojita
mkdir _build
cd _build
cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo ..
make -j4
./trojita

Please do join the #trojita channel on Freenode and tell me how you like this application. I'm open to any suggestions and would love to hear any feedback, too.

---

As you can see, this blog is a static HTML page, so you can't post any comments here. However, I'm eager to answer any questions sent to my mail, both via e-mail and in subsequent blog posts.

If you are looking for a nice dark theme for the Qt Creator, you might want to try my adaptation of the inkpot vim theme. Just save it as ~/.config/Nokia/qtcreator/styles/inkpot.xml and select it in the Tools -> Options -> Text Editor -> Color Scheme.

Please note that this might need a git version of the Qt Creator. Previous releases did not have the feature of switching between several editor themes. Therefore, if you don't have the corresponding item in the settings dialog, put the following into your ~/.config/Nokia/QtCreator.ini:

[TextEditor]
FontFamily=Terminus
Selection="#ffffff;#678db2;false;false"
LineNumber="#8b8bcd;#2e2e2e;false;false"
SearchResult="#000000;#ffef0b;false;false"
SearchScope="#000000;#f8fafc;false;false"
Parentheses="#ffff00;invalid;true;false"
CurrentLine="#000000;#2d2d32;false;false"
Number="#506bbd;invalid;false;false"
String="#ffcd8b;#404040;false;false"
Type="#ff8bff;invalid;false;false"
Keyword="#808bed;invalid;false;false"
Operator="#409040;invalid;true;false"
Preprocessor="#409040;invalid;false;false"
Label="#e76000;invalid;false;false"
Comment="#cd8b00;invalid;false;false"
DisabledCode="#a0a0a4;invalid;false;true"
AddedLine="#00aa00;invalid;false;false"
RemovedLine="#ff0000;invalid;false;false"
DiffFile="#8484f3;invalid;false;false"
DiffLocation="#0084ff;invalid;false;false"
Text="#cfbfad;#1e1e27;false;false"

The Closest Book Meme

Apologies to the readers who expected a technical post, this is OT and just a response to Ryan.

I can't promise that I will love you forever, but I can promise that I will stay alive, so that I can call you, so that I can need you, so that I can commune with you, so that I can embrace you.

This is my translation of a quotation from the Czech edition of Louis Evely's Amour et Mariage (Lovers in Marriage is the English title). My translation doesn't match the level of the original (it's not technical English after all), but it's a great book worth reading, really.