Slashdot Mirror

I have been using Qt for the last 1.5 years to develop an application for post-processing of segmented (medical) image data as part of my master thesis. The application is available under the GPL at sourceforge

During development one major disadvantage of Qt has surfaced, and I think it shows that the Trolltech has choosen a terribly wrong solution to a complex problem.

In order to support their signals-and-slots mechanism (which is an elegant concept, and allows for easy implementation of both the model-observer pattern and the mediator pattern) they have added two new keywords to the language, namely signals and slots. In order to support these you _HAVE_ to run a preprocessor called moc (Meta Object Compiler) for your program to link. But moc does not support templates.

Mostly we have managed to work around this limitation by having a non-template superclass which declares the signals and slots (luckily slots can be virtual) and then have the template parts in a subclass, but this leads to unnatural class hierarchies.

Other libraries have managed to support a signals-and-slots mechanism without such an ugly hack. Both Boost.signals and libsic++ implement them. However their syntax is not as nice as Qt's. If C++ really need even more syntax is of course another question :-)

While not all applications rely upon templates, they have some interesting uses, and if an applications first starts to use them, most classes easily ends up as template classes. See the book Modern C++ Design for "new-school" uses of templates. This could easily be the direction C++ development is headed, and it's a shame Qt will not be able to be a part of it.

With such a control over the hardware, you are allowed to bypass the XWindows system, which kills the performance in such desktop environments as KDE and Gnome. Painting directly to the hardware buffer, buttons and other widgets can be responsive in a unique way.

The only common manner across all major platforms, BSD, Linux, yes, even windows that you can do this is via DirectX. Compiled binaries can be ported cross platform due to the quality of the cross platform implementations.

Not only this, but the breadth of the system allows realtime multimedia eventing systems, such as audio responses to important system events. Platforms such as NT incur an inherent delay, but not when using directX.

Qt: Again, doesn't work on the Mac
Qt does work on Mac OS X, and it does not require
an X server running to display, although it is not 'native' in the sense that quartz is native on OSX.
Trolltech's site
lists it, and I saw a demo once of a graphing app that was using Qt on Linux, Windows, OSX, and Windows CE, all with 2 lines of code changed across the platforms. Not too terrible.

Qt/X11 Free Edition is dual licensed under the Q Public License and the GNU General Public License.

Qt Non-Commercial Edition for Microsoft Windows is licensed under the Qt Non-Commercial license.

Qt/X11 Free Edition is dual licensed under the Q Public License and the GNU General Public License.

Qt Non-Commercial Edition for Microsoft Windows is licensed under the Qt Non-Commercial license.

Qt/X11 Free Edition is dual licensed under the Q Public License and the GNU General Public License.

Qt Non-Commercial Edition for Microsoft Windows is licensed under the Qt Non-Commercial license.

Qt/X11 Free Edition is dual licensed under the Q Public License and the GNU General Public License.

Qt Non-Commercial Edition for Microsoft Windows is licensed under the Qt Non-Commercial license.

I would be only too happy to!

Qt/X11 Free Edition (Unix)
Qt/Embedded Free Edition
Qt/Windows Non-Commercial Edition

I would be only too happy to!

Qt/X11 Free Edition (Unix)
Qt/Embedded Free Edition
Qt/Windows Non-Commercial Edition

I would be only too happy to!

Qt/X11 Free Edition (Unix)
Qt/Embedded Free Edition
Qt/Windows Non-Commercial Edition

Qt Now supports Mac...
See Here [Trolltech.com]

It looks like Qt does native widgets everywhere. I haven't coded with it, but source compatibility bewteen Windows, OS X, X11, and Qt/Embedded seems pretty promising. But personally, I'm still using the tried and true cross platform GUI toolkit known as HTML :)

It looks like Qt does native widgets everywhere. I haven't coded with it, but source compatibility bewteen Windows, OS X, X11, and Qt/Embedded seems pretty promising. But personally, I'm still using the tried and true cross platform GUI toolkit known as HTML :)

It looks like Qt does native widgets everywhere. I haven't coded with it, but source compatibility bewteen Windows, OS X, X11, and Qt/Embedded seems pretty promising. But personally, I'm still using the tried and true cross platform GUI toolkit known as HTML :)

Trolltech's QT costs $1550 each, per developer, for commercial use on Windows and Mac.

QT versus Java (PDF file)

QT versus MFC, in English (See the French below.)

QT versus MFC, in French (MFC contre Qt)

Trolltech's QT costs $1550 each, per developer, for commercial use on Windows and Mac.

QT versus Java (PDF file)

QT versus MFC, in English (See the French below.)

QT versus MFC, in French (MFC contre Qt)

I don't know all the details on the license bundled for this package, but I saw a boxed version of QT on Trolltech's website the other day : http://www.trolltech.com/products/box.html

The page says "The Qt 3.0 box is offered in addition to the Qt license purchase for $149". Not sure, but it seems that you can use it on Linux/Win. Anyone know more about that, especially the license (can you write non-GPL apps (LGPL, BSD, closed, etc.) ?

If Apple has really done this with a wrapper, could this mean, that we may get a lot more qt programs ported to MacOS X?!? Another reason to buy a Mac?

You don't need a wrapper for Qt on the mac. Qt/Mac has been out for some time now, though it's gotten surprisingly little press. It's source compatible with Qt/Windows, and provides *real* native aqua controls (unlike MacGtk) via carbon. Yes, "Another reason to buy a mac". Is someone keeping a list somewhere?

And was QT cross-platform at the time the decisions about xul were being made?

Yes, it had been for years.

Did it run on non-x86 platforms at the time?

Yes, again, for years.

What about now?

Check it out yourself.

What about the license at the time?

I believe it was available under the QPL and the GPL. Whilst the GPL is fine for Mozilla (you can dual-license easily), Netscape would have had to purchase QT licenses to release Netscape as closed-source. That's hardly a big deal compared with the developer costs associated with doing it yourself.

It always easier in hindsight to chastise anyone's decision, especially when you're not the one who has to make it.

Chastise? Read my post again. I said it was a shame they didn't use something that was already available, cheap, and proven.

The gtk thing has nothing to do with the core Mozilla project

They chose to use it. One of their stated goals was to have a cross-platform browser. GTK wasn't very cross-platform at the time, it was quite unstable on Windows, and I don't even know if it supported the Mac back then. It was definitely inferior to the job at the time, and many people would argue it still is.

QT isn't a replacement for Javascript. Totally different problem domains.

Javascript, in combination with XUL, is used to build the Mozilla application. They eschewed traditional toolkits, and developed a user interface based around xml and javascript. To say that Javascript is unrelated to their decision to not use QT is ill-informed at best.

I mean, if the Apple folks were able to port KHTML to OpenStep^WMac OS X from that whole Linux-QT-KDE mess, it can't be that bad, can it?

Repair the perception by explaining to me how I'm going to get rich by creating software.

If you actually meant "make an honest living" instead, then there are plenty of examples: Dual licensing, Hardware bundling, the "ransom" model, etc.

No... the GPL represents a software distribution model that favors the rights of the user over the rights of the producer.

(Notwithstanding that the intent of the GPL was to discard the notion of producers and consumers in software. Any user can become a producer if they want to.)

Largely because it's motivated by envy and spite rather than any positive virtues.

I really wish people would open their eyes to new possibilities, instead of blindly fighting things that they just don't understand.

Everything it sounds like you need to do can be done through Qt. It's now available by default on most linux systems, and is highly cross platform (ie. Windows, Mac, Linux, Solaris, ...). It provides everything you need to make all sorts of applications, as well as allowing you to embed GL widgets. It's GPL, and let's you choose whether you want to use native widgets (eg. toolbars, check boxes, etc) or custom widgets through styles.

Everything it sounds like you need to do can be done through Qt. It's now available by default on most linux systems, and is highly cross platform (ie. Windows, Mac, Linux, Solaris, ...). It provides everything you need to make all sorts of applications, as well as allowing you to embed GL widgets. It's GPL, and let's you choose whether you want to use native widgets (eg. toolbars, check boxes, etc) or custom widgets through styles.

Don't tell me you don't know Qt !!! it's the best, totally cross platform, and definitely preserving the look and feel of the host O/S. And it is not only a GUI toolkit, it has everything:

native look and feel

database support

OpenGL support

XML through SAX and DOM implementations

true componentatization through the signal-and-slot mechanism

theme support

app settings and DLL transparent handling

lots of container templates which are easy to use

full visual environment intergrated nicely with various IDEs

source code 100% compatibility from platform to platform

multithreading and synchronization abstraction using the native O/S

networking abstraction using the native O/S

regular expression handling

HTML support

internationalization support with the easiest handling of UTF-8, ASCII and UNICODE formats

some of the best widget sets with full geometry management

follows C++ logic, unlike other toolkits like MFC or wxWindows

Its only downside is that you have to pay for it, but it is definitely worth it, because it is simply the best toolkit out there!!!

It's based on ECMAscript, so it's not really learning a whole other language. This was smart on TrollTech's part - no one's interested in learning a whole other language just to interface with pretty widgets. This'll make it very accessible to a lot of developers.

Should open up some interesting possibilities for KDE, too.

One of the biggest problems I've found when developin free software is I'll think "Ooo... this toolkit/framework has the features I need" (happened with GTK+ about a year ago) and then it'll take a month to find documentation or guides about it or figure it out from scratch myself.

So use Qt rather than GTK+ then. ;)

Seriously, the Qt documentation is superb. Complete, comprehensive, up-to-date, easy to read and navigate, and with a very good set of tutorials that range from a simple 'Hello World' app through to a full-blown game and a charting app. It's excellent even by Windows standards - but then, it has to be, because it gets sold with that documentation on Windows. Check it out here.

Don't assume that simply because some X toolkits have poor documentation (and unfortunately GTK+ is one of the poorer examples) that all of them do.

From the Trolltech FAQ:

What kind of licenses exist for Qt?
The Qt toolkit is available under two different licenses: The Professional and Enterprise Editions for commercial use on all platforms, and the Free Edition for developing free/open source software for the X11 platform.

For those thinking to develop with the free edition, then just buy a license when they're ready to deploy:

Can we use the Free Edition while developing our non-free application and then purchase commercial licenses when we start to sell it?
No. The Free Edition license applies to the development phase - anything developed without Professional or Enterprise Edition licenses must be released as free/open source software.

The minimal price for a single platform commercial license is $1240USD. See Trolltech - Pricing Desktop.

The price is very reasonable for the functionality, but I only have so much money to spend on tools, and I'm not willing to plunk down the coin now just in case I need to be able to use my code commercially (i.e. to support a client site.)

From the Trolltech FAQ:

What kind of licenses exist for Qt?
The Qt toolkit is available under two different licenses: The Professional and Enterprise Editions for commercial use on all platforms, and the Free Edition for developing free/open source software for the X11 platform.

For those thinking to develop with the free edition, then just buy a license when they're ready to deploy:

Can we use the Free Edition while developing our non-free application and then purchase commercial licenses when we start to sell it?
No. The Free Edition license applies to the development phase - anything developed without Professional or Enterprise Edition licenses must be released as free/open source software.

The minimal price for a single platform commercial license is $1240USD. See Trolltech - Pricing Desktop.

The price is very reasonable for the functionality, but I only have so much money to spend on tools, and I'm not willing to plunk down the coin now just in case I need to be able to use my code commercially (i.e. to support a client site.)

I tend to take your comment regarding employment of Linux-based professionals unkindly, btw, being that it's simply false -- serious UNIX admins and coders are quite frequently better paid than their Windows-centric counterparts.

The problem with programming at the lower level, like Xlib, is that it takes 2 years to get the first version of your program out. Then you move on to Xt and now it only takes only 1 year. Then you move on to Motif and it only takes you 6 months. Then you move on to Qt and it only takes 3 hours. Of course you want it to look slick so you use kdelibs.

It's mentionned on the 3.1b1 Changelog near the end.

In both cases, however, you'd have to get the Opie source and re-compile them for X86 since the ipk's are all pre-compiled for the Z.

Honestly, if you've got a Zaurus, the easiest way to try it is to just back up everything and flash OZ. It's just not that hard to flash back and forth. I did it in the very early days and went almost immediately back to the Sharp ROM and just restored the data. Then I went to Paul Flinders "enhanced" (/home on SD card) rom. Since OZ 2.9.5-beta-something, however, I haven't looked back.

In both cases, however, you'd have to get the Opie source and re-compile them for X86 since the ipk's are all pre-compiled for the Z.

Honestly, if you've got a Zaurus, the easiest way to try it is to just back up everything and flash OZ. It's just not that hard to flash back and forth. I did it in the very early days and went almost immediately back to the Sharp ROM and just restored the data. Then I went to Paul Flinders "enhanced" (/home on SD card) rom. Since OZ 2.9.5-beta-something, however, I haven't looked back.

I would highly recommend Qt (from TrollTech). I have used it for several C++ cross-platform projects (across HP-UX, Linux, and Win32), and I've been very successful with using Qt and very happy with Troll's support.

While I can see benefits for also using GCC on each platform, I have found that sticking to the commercial compiler for the system in question (ie. Visual C++ on Windows, SunPro on Solaris, etc.) generally produces faster code, since it sounds like that may be an issue for you. Qt is generally pretty flexible when it comes to this so you should be OK whatever you use.

I would not recommend Java if performance or reliability is at all an issue. Performance because Java just isn't there yet. Reliability (and supportability) because you're going to be adding an extra layer of support issues for any problems you run into with the JRE component for each and every platform you need to support.

I am graduate student, and as a part of my masters thesis, I am involved in the development of a behaviral modeling environment . We are using the programing language python, and the GUI toolkit QT and PyQT. The choice of these technologies has made our tool fairly generic as it runs without a glitch on Linux, Solaris and win2k. We have not tested it on other platforms but it should work on all the platforms which run python. Python is a really cool programing language and PyQT makes cross-platform GUI development really easy. We have developed fairly involved GUIs using PyQT, like a Topology Editor, Schematic Editor (to capture the design and topology of circuits) etc. I would strongly recommend python and PyQt to someone interested in developing cross-platform applications (with GUIs)

I said this somewhere else in this message tree, but I want to say it near the top where you will definately see it. If switching to gcc on all platforms isn't feasible for any reason, then qmake is definately the answer to your building nightmares. qmake is a meta-make system that creates makefiles for many-many platform/compiler combinations (including all the ones you mentioned).

qmake allows you to write one project (.pro) file for all platforms. qmake then creates makefiles for any of its supported platforms for you. It takes some getting used to, but it is very powerful and I couldn't imagine working on a cross-platform project without it.

qmake comes with Qt, so you'll have to pay to use if for commercial use, but developer liscenses are reasonable (probably less than $20k for all seven of you). Actually, you may be able to use qmake for free, but other portions of Qt would definately come in handy for you as well -- especially if your application has a large GUI component.

I've had some experience doing just that. To date, Qt is the most mature of those and will give you uniform access to GUI, networking, threading and even database access for Win32, Unices (including Linux) and MacOS.

If you aren't so worried about GUIs but need to output multimedia contents portably, SDL is a viable alternative. The portability of some of the more esoteric components is dubious but SDL has the distinct advantage of being completely free.

As for performance concerns some people have raised about archaic versions of GCC, don't let that stop you-- even if you don't use GCC 3.2 (which produces very good code) the subtle improvement is speed is very rarely worth the greatly increased complexity in development and maintenance.

Besides, with recent GCCs I'm hard-pressed to actually find any significant difference between code generated by it and other compilers (for IA32, anyways, and with all relevant optimizations turned on).

-- MG

Have you looked at Qt? It supports all the platforms you are developing for. It is primarily a platform independent GUI toolkit, but it also got a lot of other stuff like container classes (if you for some reason won't use stl), thread support, sql classes, xml classes and socket classes, all which are platform independent. It is not only just a portable GUI toolkit, I think it is the best GUI toolkit there is. I recommend it even if you're writing for Windows only. If you think of Qt more as a platform than a GUI toolkit, writing applications that run on multiple platforms (with native speed) may be easier than you think. (I'm not an employee of trolltech, although I am wearing a Qt t-shirt as I write this :)

Qt from Trolltech gives you a cross-platform GUI library, that creates applications looking natively on each OS (Windows, Mac OSX and GNU/Linux).

I would suggest first using gcc on all UN*X platforms, and also trying out something like ant instead of the various forms of make you're dealing with now.

Also, have you considered using a library like Qt to handle most of the porting details? It's not free, but it is good if you can deal with it's oddities (I personally consider preprocessing to be evil).

Good luck.

The initial port of Mozilla to Qt occurred immediately after the Mozilla source was released. I wasn't there myself, but apparently it was a 5 day (and night) event. More info on the current status of QtMozilla here

X-Windows is never going to cut it in the desktop world

Please explain why X-Windows won't cut it. I hear a lot of people bashing X, because X is supposed to be slow, tedious to program for, a memory hog, and a pain in the ass. However, I've noticed that my X desktop doesn't eat memory like the gluttenous pig it's being accused to be. I've noticed that it's really not that slow on a halfway decent machine (a P-200 was pretty responsive, even when using enlightenment with all bells and whistles). I've noticed that other APIs to do programming for proprietary windowing systems can be just as tedious and nervewrecking as Xlib/Motif/etc can be (gtk+ and QT are actually pretty good alternatives, but that should be pretty old news by now). A pain in the ass, I can't debate with that, but so are other windowing systems in different areas.

Why don't these software companies do what their supposed to do and actually program something.

Debian is not a software company, it's volunteer based

Linux will never make it to the desktop.

Perhaps we won't, perhaps we will... I've had hours of fruitless debates about this, and we've always come to that conclusion. Only time will tell. The apps aren't there yet, but getting there. The desktop isn't uniform enough, but Redhat is making the first attempt, with many others including debian.

the Linux community has to stop thinking like Sun, W3C and all these other monstrousities that crank out new ideas less frequently than LucasFilm does

I doubt that most of us think like Sun and w3c. Most kernel developers don't think like sun, and I think that w3c is overall a good thing (except for the patenting issues) because we need some standards. Oh, I don't mean that everyone should use XML for their new applications (goddess forbid), but at least HTML should be HTML and not some derived alphabetsoup with proprietairy extensions.

They need a revolution of thought that makes customers proud to stand behind their product.

How about freedom? That thought is still quite revolutionary to most people when it comes to source code.

If you're not happy with XFree, try to find an alternative... You'll find that you'll be switching back to X very quickly. But you can always contribute to one of those projects. Perhaps by programming, or perhaps by testing and sending bug reports or writing documentation. There won't be any good alternatives unless someone does some work on them.

(context for mods) let's see... ELF... elves... races in fantasy and science fiction:

No. Trolls

Look at that troll. Isn't it Qt?

are completely different creatures from hobbits and elves.

let's see... among (semi) intelligent roughly-humanoid races, the fantasy multiverse has at least humans, dwarves, elves, hobbits, ents, weebles, smurfs, cyclopes, gnomes (pronounced g; 90 cm tall), gnomes (silent g; 15 cm tall), trolls, orcs, merfolk, selkies, marsh-wiggles, nerdlucks, jawas, tuskens, wookiees, ewoks, teeks, borrowers, morlocks, and eloi.

Saturday, Saturday, Saturday! Watch the Race Race at the Motor Speedway!

Be there.

This is my humble opinion on how to design a good interface:

1. Define your 'document', i.e. the data you're going to work with as a set of classes.

2. Define a user interface that lets you access these classes (their methods and properties) when they are relevant.

3. Make sure to analyse what functions that are going to be used most, make them one, or at worst two-click commands.

There are a number of ways of showing information to the user. I list a few good ways here, no special order:

* Show global information in a status area that is globally (read always) visible.

* Show local information in a special area, so that the options for a line and a box appear in the same place even though they may contain different options.

* Provide two interfaces for complex operations, one wizard (with an 'don't show this again'-option) and one dialog (possibly with tabs) allowing the advanced user to pick the items that he/she needs.

* Use context menus (right clickable or automatically appearing in the menu bar).

* Make frequently used commands (let the user choose, but supply an intelligent default) on a toolbar. Let these buttons simply trigger a standard command, i.e. no extra code here!

If you have done your document classes right it shouldn't be too hard to add all the inteface classes around them. Perhaps you will have to handle some states in a view, etc. But otherwise it should just be a matter of wrapping the document into something UI like.

As for tools I must say avoid MFC (i mean *run* if you hear it mentioned, it is not a serious option). The same applies to Borland's alternative (I cannot remember what it is called). If you are forced to write in C, use GTK and perhaps Gnome, but be prepared to write OO code in C, and a huge dependency problem if you use Gnome. Also, portability is not always what it aught to be. If you have the freedom to use C++, use Qt. It is portable, beautifully designed and works flawlessly.

I must also say that the implementation 'method' I presented above fits very nicely into Qt. I think (haven't tried any big projects with it yet) that it is quite easy to do in GTK too.

If time was money we should all sit around waiting to get rich.

I must recommend Qt. You'll get neat code, portable to Win32, X-windows, BeOS, etc. Get it from Trolltech!

>[Qt is fully GPL] Only when compiling for the X11 target

Not if you purchase a license! Qt is well worth the money!

Only if you're in a for-profit business. Qt/Mac will expire after 30 days. Most hobbyist developers (such as myself) don't have upwards of $1500 for a widget set. And according to this FAQ entry, Trolltech releases Qt Free Edition only for operating systems that are free software. Thus, Trolltech will not release Qt for Windows until ReactOS is complete, nor Qt for Mac as free software until GNUstep is complete.

>[Qt is fully GPL] Only when compiling for the X11 target

Not if you purchase a license! Qt is well worth the money!

Only if you're in a for-profit business. Qt/Mac will expire after 30 days. Most hobbyist developers (such as myself) don't have upwards of $1500 for a widget set. And according to this FAQ entry, Trolltech releases Qt Free Edition only for operating systems that are free software. Thus, Trolltech will not release Qt for Windows until ReactOS is complete, nor Qt for Mac as free software until GNUstep is complete.

>[Qt is fully GPL] Only when compiling for the X11 target

Not if you purchase a license! Qt is well worth the money!

Only if you're in a for-profit business. Qt/Mac will expire after 30 days. Most hobbyist developers (such as myself) don't have upwards of $1500 for a widget set. And according to this FAQ entry, Trolltech releases Qt Free Edition only for operating systems that are free software. Thus, Trolltech will not release Qt for Windows until ReactOS is complete, nor Qt for Mac as free software until GNUstep is complete.

>[Qt is fully GPL] Only when compiling for the X11 target

Not if you purchase a license! Qt is well worth the money!

Only if you're in a for-profit business. Qt/Mac will expire after 30 days. Most hobbyist developers (such as myself) don't have upwards of $1500 for a widget set. And according to this FAQ entry, Trolltech releases Qt Free Edition only for operating systems that are free software. Thus, Trolltech will not release Qt for Windows until ReactOS is complete, nor Qt for Mac as free software until GNUstep is complete.