GTK-server

GTK-server is an open-source project released under the GNU General Public License. The GTK-server project aims to bring Graphical User Interface programming to any interpreted language using the GIMP Tool Kit (GTK) or XForms.

Philosophy

The GTK-server provides a stream-oriented interface to GTK. If the GTK-server is compiled as a standalone binary, it allows five different interfaces: stdin, fifo (named pipe), ipc (message queue), tcp or udp. Any interpreted language or shellscript with I/O capabilities can start the GTK-server with an argument specifying the type of interface, and can start sending GTK function calls in S-Expression format. After each request, the GTK-server returns a result, depending on the type of GTK function invoked.

If the GTK-server is compiled as a shared object, it exports the function 'gtk', which must be imported in the client program first. After that, the client program can start sending GTK function calls in S-Expression format as argument to the imported 'gtk' function.

Before the GTK-server actually can execute GTK functions, it has to read a configuration file in which the prototypes of the GTK functions are described. Since version 2.2.3 this also can be done on-the-fly, allowing the GTK-server to run without configuration file.

Implementation

Implementing the GTK-server leads to the following considerations.

* Accessing foreign functions is only possible when the accessed libraries are created with a non object oriented programming language like C or Pascal. Libraries created with C++ for example, use name mangling in order to unify overloaded functions. This means that the actual functionname in a C++ library cannot be known once the shared library has been compiled. Hence the functions in such a library cannot be accessed. Therefore, libraries like wxWidgets, the Qt toolkit, FLTK which are programmed in C++, cannot be accessed with the GTK-server concept.
* The GTK library was implemented in the C programming language. Since C is a strongly typed programming language, the interpreted program needs to know the type of arguments and the type of the return value for each GTK function during runtime. These can be defined on-the-fly or in a configuration file, which is parsed by the GTK-server during startup. However, the GTK-server does not know the actual functions which are going to be used by the interpreted client program, so for GTK-server all arguments and return values for each GTK function are variable types.

This leads to a problem for the implementation, because the GTK functions and the corresponding arguments and return values cannot be hardcoded into the GTK-server binary.

The way to resolve this is by using a foreign function interface. Currently, four external foreign function interfaces are supported by GTK-server: libffi, FFCALL, C/Invoke and dyncall. One of these libraries should be available on the target system, in order to compile the GTK-server successfully.

Example

The following KornShell script starts the GTK-server in stdin mode, and creates a simple window with an exit button:

#!/bin/ksh

# Start GTK-server
gtk-server -stdin , &

# Communicate with GTK-server and assign function
function gtk
function define

# Setup GUI
gtk "gtk_init NULL NULL"
define WINDOW gtk "gtk_window_new 0"
gtk "gtk_window_set_title $WINDOW 'Korn GTK-server demo'"
gtk "gtk_window_set_default_size $WINDOW 400 200"
define TABLE gtk "gtk_table_new 10 10 1"
gtk "gtk_container_add $WINDOW $TABLE"
define BUTTON gtk "gtk_button_new_with_label 'Click to Quit'"
gtk "gtk_table_attach_defaults $TABLE $BUTTON 5 9 5 9"
gtk "gtk_widget_show_all $WINDOW"

# Mainloop
until , $EVENT = $WINDOW
do
define EVENT gtk "gtk_server_callback wait"
done

# Exit GTK-server
gtk "gtk_server_exit"

Advantages and limitations

Although GTK was meant to be used with the C programming language, it is now possible to use GTK from any interpreted language without changing the actual implementation of the interpreter. Also, GTK 1.x, GTK2.x and GTK 3.x can be reached. Optionally, any other shared library can be used, like OpenGL related libraries, Poppler, Mozilla, but also libc, sqlite and a music library like MikMod.

When using the GTK-server as a standalone binary, it inevitably creates an additional process in the processlist. Also, GTK functions defined as a macro cannot be reached by a client program.

References

{{Reflist, refs=
{{citation
, url = https://tldp.org/HOWTO/C++-dlopen/index.html
, title = C++ dlopen mini HOWTO
, first = Aaron
, last = Isotton
, work = The Linux Documentation Project
, date = 2006-03-16
, access-date = 2021-09-07
, archive-url = https://web.archive.org/web/20210812142103/https://tldp.org/HOWTO/C++-dlopen/index.html
, archive-date = 2021-08-12
, url-status = live
{{citation
, url = https://www.haible.de/bruno/packages-ffcall.html
, title = FFCALL Libraries
, access-date = 2021-09-07
, archive-url = https://web.archive.org/web/20210701220204/https://www.haible.de/bruno/packages-ffcall.html
, archive-date = 2021-07-01
, url-status = live
{{citation
, url = http://www.nongnu.org/cinvoke/
, title = C/Invoke
, access-date = 2021-09-07
, archive-url = https://web.archive.org/web/20210820012035/http://www.nongnu.org/cinvoke/
, archive-date = 2021-08-20
, url-status = live
{{citation
, url = https://dyncall.org/
, title = dyncall.org - calling C functions dynamically
, access-date = 2021-09-07
, archive-url = https://web.archive.org/web/20210416121417/https://dyncall.org/
, archive-date = 2021-04-16
, url-status = live

GTK
Application programming interfaces
X-based libraries