Re: FOSDEM GTK+ brochure

[Sébastien Wilmet <swilmet gnome org>]

On Thu, Jan 08, 2015 at 05:12:28PM +0100, Olav Vitters wrote:
> On Thu, Jan 08, 2015 at 03:48:35PM +0100, Sébastien Wilmet wrote:
> > I've finished an initial version:
> > https://people.gnome.org/~swilmet/gtk-brochure.pdf
> > https://github.com/swilmet/gtk-brochure
>
> As text to make it easier for members to review and respond:

Updated text:

The GLib/GTK+ Development Platform


GTK+ is a multi-platform toolkit for creating graphical user interfaces.
Offering a complete set of widgets, GTK+ is suitable for projects ranging from
small one-off tools to complete application suites.

GTK+ is written in C but has been designed from the ground up to support a wide
range of languages, not only C/C++. Using GTK+ from languages such as Python
and JavaScript (especially in combination with the Glade GUI builder) provides
an effective method of application development.

GTK+ is free software and part of the GNU Project. The licensing terms for
GTK+, the GNU LGPL, allow it to be used by all developers, including those
developing proprietary software, without any license fees or royalties.

GTK+ has been created in 1996 for the GIMP --- the GNU Image Manipulation
Program --- but quickly evolved into a general-purpose library used by a large
number of applications including the GNU project's GNOME desktop.


Architecture Overview

Over time GTK+ has been built up to be based on other libraries, also developed
by the GTK+ team:

 * GLib, a low-level core library that forms the basis of GTK+. It provides data
structure handling for C, portability wrappers and interfaces for such run-time
functionality as an event loop, threads, dynamic loading, an object system
(GObject) and high-level input/output APIs (GIO).

 * Pango, a library for layout and rendering of text with an emphasis on
internationalization. It forms the core of text and font handling for GTK+.

 * Cairo, a library for 2D graphics with support for multiple output devices
(including the X Window System, Win32 and Quartz) while producing a consistent
output on all media while taking advantage of display hardware acceleration
when available.

 * ATK, a library for a set of interfaces providing accessibility. By
supporting the ATK interfaces, an application or toolkit can be used with tools
such as screen readers, magnifiers, and alternative input devices.

 * GDK is the abstraction layer that allows GTK+ to support multiple windowing
systems. GDK provides backends for X11, Windows, Mac OS X, Wayland, Mir, and a
web browser.


GLib -- the Core Library

Firstly, GLib provides common data structures:

 * Single and doubly linked lists.

 * Hash tables.

 * Balanced binary trees.

 * N-ary trees: trees of data with any number of branches.

 * Strings with text buffers which grow automatically as text is added.

 * Arrays of arbitrary elements which grow automatically as elements are added.

 * GVariant, a generic data type that stores a value along with information
about the type of that value.

 * And a few other data structures.

GLib also contains loads of utilities:

 * String and Unicode manipulation.
 * Date and time functions.
 * A command-line option parser.
 * Perl-compatible regular expressions.
 * An XML parser.
 * A unit-test framework.
 * And many other utilities.

Last, but not least, GLib provides some core event-driven programming features,
with a main event loop, support for threads and asynchronous communication
between threads. An event loop listens some sources of events, that can come
from file descriptors (plain files, pipes or sockets), timeouts, or other
custom sources. A priority is associated with each source of events. When an
event arrives, the event loop dispatches it to the application. The event can
then be taken into account, either in the same thread or another thread.

Event-driven programming is not only useful for graphical user interfaces (with
user events such as key presses and mouse clicks), but also for daemons that
respond to hardware changes (a USB stick inserted, a second monitor connected,
a printer low on paper), or software that listen to network connections or
messages from other processes, and so on.

GObject -- an Object System

Most modern programming languages come with their own native object systems and
additional fundamental algorithmic language constructs. Just as GLib serves as
an implementation of such fundamental types and algorithms (linked lists, hash
tables and so forth), GObject provides an implementation of a flexible,
extensible, and intentionally easy to map (into other languages)
object-oriented framework for C. The substantial elements that are provided can
be summarized as:

 * A generic type system to register arbitrary single-inherited flat and deep
derived types as well as interfaces for structured types. It takes care of
creation, initialization and memory management of the assorted object and class
structures, maintains parent/child relationships and deals with dynamic
implementations of such types. That is, their type specific implementations are
relocatable/unloadable during runtime.

 * A collection of fundamental type implementations, such as integers, doubles,
enums and structured types, to name a few.

 * A fundamental type implementation to base object hierarchies upon -- the
GObject base class.

 * A signal system that allows very flexible user customization of
virtual/overridable object methods and can serve as a powerful notification
mechanism. For example a GTK+ widget displaying text can send a signal when
some text is inserted, so the application can connect to the signal by
attaching a callback function that is called when the signal is emitted.

 * An extensible parameter/value system, supporting all the provided
fundamental types that can be used to generically handle object properties or
otherwise parameterized types. A property is like an object attribute, but a
signal is emitted when its value changes. For instance a check button in GTK+
has the active boolean property that tells whether the check button is checked
or not. An application can attach a callback to the notify signal to be
notified when the state of the check button is modified.

GIO -- Input/Output on Steroids

GIO is striving to provide a modern, easy-to-use Virtual File System (VFS) API
that sits at the right level in the library stack. GIO also contains other
generally useful APIs for desktop applications (such as networking and D-Bus
support). It was created to provide an API that is so good that developers
prefer it over raw POSIX calls. Among other things that means using GObject. It
also means not cloning the POSIX API, but providing higher-level,
document-centric interfaces.

The abstract file system model of GIO consists of a number of interfaces and
base classes for I/O and files. Then there is a number of stream classes,
similar to the input and output stream hierarchies that can be found in
frameworks like Java. There is a framework for storing and retrieving
application settings. There is support for network programming, including
connectivity monitoring, name resolution, lowlevel socket APIs and highlevel
client and server helper classes. There is support for connecting to the D-Bus
inter-process communication system: sending and receiving messages, owning and
watching bus names, and making objects available on the bus. Beyond these, GIO
provides: file monitoring; utility classes to implement asynchronous and/or
cancellable operations; an easy-to-use API to launch and interact with child
processes; and more.

In addition to the interfaces, GIO provides implementations for the local case.
Implementations for various network file systems are provided by the GVFS
package as loadable modules. Another design choice is to move backends
out-of-process, which minimizes the dependency bloat and makes the whole system
more robust. The backends are not included in GIO, but in the separate GVFS
package. The GVFS package also contains a daemon which spawn further mount
daemons for each individual connection.

The GTK+ Widget Toolkit

On top of GLib/GObject/GIO sits GTK+, a library containing a wide range of
widgets. A widget is a basic component of a graphical user interface, for
instance a button, some text, a menu, etc. A container is a special widget that
can contain other widgets. Another special type of widget is a toplevel widget,
i.e. a window. All these widgets are (indirect) subclasses of the GObject base
class.

Although widgets can be created, configured and assembled programmatically, the
Glade interface builder can be used to create the user interface graphically.
The Glade application creates an XML file that can be loaded with GTK+.

Among other things, GTK+ provides a flexible theming system with a CSS-like
syntax, as well as an interactive inspector.

Release Schedule and Versioning Scheme

Every six months there are new GLib, GObject, GIO, GTK+ and GNOME stable
releases, around March and September. A version number has the form X.Y.Z,
where ``Y'' is even for stable versions and is odd for unstable versions. A new
minor stable version (e.g. 3.14.0  3.14.1) doesn't add new features, only
translation updates, bug fixes and performance improvements. For a library, a
new major version number (``X'' in X.Y.Z) generally means there has been an API
break. To address this, previous major versions are parallel-installable with
the latest version.

It's recommended to use the latest versions for newly-written code.

More Information

http://www.gtk.org/