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/ _______________________________________________ engagement-list mailing list [email protected] https://mail.gnome.org/mailman/listinfo/engagement-list
