gtkmm Frequently Asked Questions

gtkmm's place in the world

What is GTK+?

GTK+ is the GUI widget toolkit, written in C, which serves as the foundation for the GNOME project as well as many stand-alone applications. GTK+ is the foundation on which gtkmm is built. See http://www.gtk.org/ .

What is gtkmm?

gtkmm is a C++ wrapper for GTK+. That is, it is a language binding that lets you use GTK+ from C++. This includes support for C++ features such as inheritance, polymorphism and other powerful techniques which C++ programmers expect to have at their disposal.

Why is it named gtkmm?

gtkmm was originally named gtk-- because GTK+ already has a + in the name. However, as -- is not easily indexed by search engines the package generally went by the name gtkmm, and that's what we stuck with.

Why use gtkmm instead of GTK+?

gtkmm allows you to write code using normal C++ techniques such as encapsulation, derivation, and polymorphism. As a C++ programmer you probably already realize that this leads to clearer and better organised code.
gtkmm is more type-safe, so the compiler can detect errors that would only be detected at run time when using C. This use of specific types also makes the API clearer because you can see what types should be used just by looking at a method's declaration.
Inheritance can be used to derive new widgets. The derivation of new widgets in GTK+ C code is so complicated and error prone that almost no C coders do it. As a C++ developer you know that derivation is an essential Object Orientated technique.
Member instances can be used, simplifying memory management. All GTK+ C widgets are dealt with by use of pointers. As a C++ coder you know that pointers should be avoided where possible.
Less code. The GTK+ C object model uses prefixed function names and cast macros. For instance: gtk_button_set_text(GTK_BUTTON(button), "sometext");
- gtkmm C++ code is shorter and clearer. For instance: button.set_text("sometext");
There's no need to worry about GTK+'s inconsistent reference-counting policy.

Why use libsigc++? Why not just use the regular GTK+ signal functions?

GTK+ signals aren't typesafe, so the compiler can't tell you whether your callback has the wrong number or type of arguments or return value.
They can only be used with functions or static methods. With libsigc++ callbacks can also be instance methods, using the member data of a particular object. They can also be virtual methods which you could override in a derived class.

Why isn't GTK+/GNOME itself written in C++.

C is a simpler language so more people are familiar with it, particularly on Unix.
C can be wrapped by any other language, making the API available to more developers.
GTK+ and GNOME have very well organized C code, much more sane than most of the gnarly C code that we encounter. This is partly due to it's C-based object-orientated structure.

Why not just use Qt if you like C++ so much?

gtkmm developers tend to prefer gtkmm to Qt because gtkmm does things in a more C++ way. Qt originates from a time when C++ and the standard library were not standardized or well supported by compilers. It therefore duplicates a lot of stuff that is now in the standard library, such as containers and type information. Most significantly, they modified the C++ language to provide signals, so that Qt classes can not be used easily with non-Qt classes. gtkmm was able to use standard C++ to provide signals without changing the C++ language.

Also, gtkmm and the other *mm modules allow you to build software which works more closely with the GNOME desktop.

How good is gtkmm

What systems does it run under?

gtkmm should run under any UNIX-type system with the proper compilers and libraries installed. The GNU C++ compiler (g++, part of gcc) together with the GNU toolset (such as found on Linux and *BSD systems) comprise its default build environment.

gtkmm can also be be built and used with:

Sun's Forte C++, on Solaris.
Windows, with the mingw build tools or MSVC++.

How complete is it?

gtkmm tries to offer all of the functionality offered by GTK+. This means that you should be able to do anything with gtkmm that's supported by GTK+, and do it more easily. If something isn't covered then we want to know about it.

Does gtkmm support all the C++ goodies like inheritance, polymorphism, etc?

Yes. gtkmm objects are normal C++ objects which implement the GTK+ inheritance model through C++ inheritance. You can do with the gtkmm widgets everything that you can do with any other C++ class.

Does gtkmm use Standard C++ (STL) containers such as std::string and std::list

Yes, we believe in reusing standard C++ code wherever possible. This might not be obvious at first because:

gtkmm has Glib::ustring which has almost the same interface as std::string. This new type exists because the C++ standard does not support UTF8-encoded strings.
The gtkmm API uses types such as Glib::ListHandle<int> which can be assigned to almost any standard C++ container, such as std::list or std::vector. These intermediate types have been used instead of forcing you to use any particular container.

In addition, some widgets, such as Gtk::TreeView, have interfaces which are very similar to the standard containers. For instance, you can iterate through the selected rows.

Does gtkmm force STL-style interfaces onto GTK+ widgets in a way that is inappropriate, difficult, or badly-implemented?

No, we do not force you. We have provided STL-style interfaces for some container widgets, to allow you to iterate over the child widgets, but these are in addition the the simpler interfaces. We have done this because we believe that STL-style interfaces sometimes require too much code to perform simple tasks. On the other hand, some people religiously prefer STL-code wherever possible. You have the choice.

These STL-interfaces are implemented with quite simple code and have been found to work without problems. There are no known bugs, as you can see on the bugs page.

Some classes such as Gtk::TextBuffer have only an STL-style interface. This is because the underlying widget has an STL-style interface, implemented in C. So this is the most appropriate, and easiest, way to wrap that API in C++.

Does the gtkmm API use C types, such as structs?

No, we wrap almost all parameters as C++ classes. which use C++ memory management. If you find parameters that use C types without good reason then we want to know about it.

What applications have been written in gtkmm?

Check out the list of applications on the Additional Resources page from the gtkmm site.

How does gtkmm compare to Qt?

gtkmm uses pure C++. Qt requires extensions to C++ that are parsed by the moc pre-processor.
gtkmm uses std::string, std::list, std::vector, iterators, etc. Qt has it's own Qt-specific containers.
With gtkmm normal C++ memory management can be used. Qt demands that all widgets are dealt with as pointers, and that deletion of widgets is surrendered to parent widgets.
Arrangement of widgets seems to be simpler in gtkmm. In Qt, Containers and Layouts are separate classes, and child widgets must be added to both.
The gtkmm API tends to be more explicit. The behaviour of Qt classes is often dependent upon the implicit effects of confusingly-overridden constructors.

Have you wrapped all of the GNOME APIs as well as GTK+?

Yes, we have wrapped most of the useful and stable GNOME APIs in other *mm modules.

Is gtkmm "bloated"

No, gtkmm is a thin wrapper.

Further information

Is there a gtkmm mailing list?

Yes. See the subscription page

What documentation is there for gtkmm?

There is a largely complete tutorial, automatically-generated reference documentation, and a wealth of running examples available at the gtkmm documentation page

Where can I find some example code?

See the examples directory in the gtkmm-documentation module. Most of these appear in the gtkmm book. There are also several large third-party applications whose source you can examine.

Using gtkmm

What compiler arguments should I use to compile a gtkmm program?

See the Headers and Linking section in the gtkmm book.

How can I get the GTK+ object from a gtkmm object?

If you need some GTK+ functionality which is not supported through gtkmm, you can call Gtk::Widget::gobj() (gtkobj() in gtkmm version 1.x) which will return a pointer to the plain C GTK+ data structure. You can then operate directly on this C object as you would in any GTK+ program.

How can I wrap a GTK+ widget in a gtkmm instance?

Glib::wrap() will give you a pointer to gtkmm object. It is an overloaded function, so it will give you an instance of the appropriate class.

Can I use C++ exceptions with gtkmm?

Yes, it is possible but it is not a very good idea. The official answer is that, since plain C doesn't know what a C++ exception is, you can use exceptions in your gtkmm code as long as there are no C functions in your call stack between the thrower and the catcher. This means that you have to catch your exception locally.

You will be warned at runtime about uncaught exceptions, and you can specify a different handler for uncaught exceptions. Some gtkmm methods do even use exceptions to report errors. The exceptions types that might be thrown are listed in the reference documentation of these methods.

How can I use Glade and/or libglade with gtkmm?

See the Gtk::Builder section in the gtkmm book.

What does Gtk::manage(widget) do?

This means 'The container widget will delete this widget.' Some people prefer to use it so that they don't need to worry about when to delete their widgets. Gtk::manage() should only be used when add()ing a widget to a container widget.

How can I learn about arranging widgets? I am confused by the packing options

Glade is a great way to see what can be done with GTK+ and GNOME widgets. Use Glade to explore the choice of widgets and to see how they can be put together. You should then be able to use the same settings as arguments to your widget constructors, and to the add() and pack() method. Or you could use Gtk::Builder (or libglademm) to load the GUI at runtime.

I'm used to MFC. Where's the Document and the View? or How do I use the Document/View idea? or How do I use the MVC pattern?

Document/View (which is a useful version of MVC) is not supported directly by GTK+, though it is commonly used by GTK+ programmers. However, the TextView and TreeView interfaces are split up into model and view.
The Bakery library makes it very easy for gtkmm/gnomemm C++ coders to use the Document/View framework.

How do I load pictures for use with gtkmm?

Use Gdk::Pixbuf and/or Gtk::Image. Both are easy to use and support a wide range of image file types via pixbuf loader plugins.

Is gtkmm thread-safe?

Paul Davis wrote:

Neither X, nor GDK nor GTK+ nor gtkmm are thread safe by themselves. You must use either the gdk_threads_{enter,leave}() functions to protect any and every call to GDK/GTK+/gtkmm functions, or alternatively, ensure that only a single thread makes such calls. One common way to do this is to have non-GUI threads send requests to the GUI thread via a pipe. The pipe is hooked into the main glib event loop used by GTK.

Personally, i have always used the single-threaded approach, which I find much more suitable for my apps.

Note that glibmm comes with Glib::Dispatcher, which implements a cross-thread signal using the pipe approach described above.

Andreas Rottmann added:

If you need a more sophisticated cross-thread message-passing approach, take a look at libsigc++ extras. It provides cross-thread, typesafe slot invocation on top of libsigc++ and comes with a gtkmm example.