Thread: Simple GUI framework

Originally Posted by zub

Requirements

Packages
You will need the GLib, cairo, Pango, ATK, gdk-pixbuf and GTK+ developer packages to build software against GTK+. To run GTK+ programs you will also need the gettext-runtime, fontconfig, freetype, expat, libpng and zlib packages.

Somehow, I immediately remembered the words from the movie "Apocalypse Now": "Horror! Horror has a face, and you must make a friend of horror". However, I do not want to be friends with horror. I just want something small and simple. For example, I chose greatest as framework for unit testing, not least because it consists of a single file, and its use is trivial. I never took anything beyond its extremely narrow scope.

That's true, GTK is not a simple GUI framework. However, I agree with Elkvis that it may be your best bet, due its enormous popularity (actually, I believe it is the only decent GUI framework for C).

If you are on Linux, setting it up is just a breeze. For example, on Ubuntu to setup the GTK+2 devel goes something like this:

Code:

sudo apt-get install libgtk2.0-dev

On Windows it's just a matter of downloading a zip file, extracting it into any folder, and finally setup a couple of environment variables (see this for example - the section: "Installing the GTK+2 Development Environment").

The already suggested gcc/mingw tool-chains are the recommended ones for compiling GTK+ apps, but it's not mandatory. Hopefully the link in the previous paragraph also provides (in other sections) all the info you may need to set up GTK with any compiler (I've successfully done it with Pelles C on Windows for example).

Anyway, as you asked, here's a sample GTK+2 program with 2 text-entries for the operands, a button for initiating the addition calculation and a label for displaying the result.

The ui has been done with the Glade Ui Designer (the GTK+2 version of it) which actually produces an xml file. I load this file into a GtkBuilder object inside the code. That's not mandatory. One may directly create the ui dynamically, in his/her code.

The .glade (xml) file is included in the attached zip file, along with the source code and a Windows 32bit executable (produced with the mingw-w64 tool-chain).

Here's the code, in case someone is too lazy to download the zip-file (please keep in mind that it may contains bugs, it was written in a rush... e.g. for one thing, more error-checking is required).

PS. The latest version of GTK is GTK+3, but I'm not familiar with (it is supposed to be easier than GTK+2, but they are not compatible).

Code:

#include <stdio.h>     /* for error-messages in stderr */
#include <stdlib.h>    /* strtol() */
#include <errno.h>

#include <gtk/gtk.h>

#define TXTF_RESULT     "Result: %ld"

/* our GUI (bare) abstraction */
typedef struct {
    GtkWidget *window;     /* main window */
    GtkWidget *op1, *op2;  /* text-entry widgets for the operands */
    GtkWidget *ok;         /* button widget */
    GtkWidget *result;     /* label-widget for the result */
} Gui;

/* -------------------------------------------------
 * Convert the text of the specified GtkEntry widget (te)
 * to a long int. Return FALSE on error, TRUE otherwise.
 * On success, the long int gets back to the caller via
 * the (ref) pointer.
 *
 * NOTE: On failure, the GtkEntry widget gets input focus,
 *       with all its contents selected.
 * -------------------------------------------------
 */
gboolean te_get_long_int( GtkEntry *te, long int *ref )
{
    long int temp = 0L;
    char *txt     = NULL;      /* for getting widget's text */
    char *tailptr = NULL;      /* for strtol() */

    /* sanity chekcs */
    if ( NULL == te || NULL == ref ) {
        fprintf( stderr, "%s: NULL pointer argument ", __func__ );
        return FALSE;
    }

    /* get widget's text */
    txt = g_strdup( gtk_entry_get_text(te) );

    /* validate it as long int */
    errno = 0;
    temp = strtol( txt, &tailptr, 10 );
    if ( ERANGE == errno || '\0' != *tailptr ) {
        gtk_widget_grab_focus( GTK_WIDGET(te) );
        gtk_editable_select_region( GTK_EDITABLE(te), 0, -1 );
        g_free( txt );
        return FALSE;
    }
    g_free( txt );

    /* update ref & exit */
    *ref = temp;
    return TRUE;
}

/* -------------------------------------------------
 * Callback function connected to the "clicked"
 * signal for the OK button.
 * -------------------------------------------------
 */
void on_clicked_button_ok(
    GtkWidget  *button,
    Gui        *gui
    )
{
    long int op1, op2;

    /* avoid compiler warnings for unused arg*/
    (void)button;

    /* sanity check */
    if ( NULL == gui ) {
        fprintf( stderr, "%s: NULL pointer argument!\n", __func__ );
        return;
    }

    /* get & validate operands */
    if ( !te_get_long_int( GTK_ENTRY(gui->op1), &op1 )
    || !te_get_long_int( GTK_ENTRY(gui->op2), &op2 )
    ){
        goto ret_failure;
    }

    /* Calc & display the result */
    char *txt = g_strdup_printf( TXTF_RESULT, op1 + op2 );
    gtk_label_set_text( GTK_LABEL( gui->result ), txt );
    g_free( txt );

    return;

ret_failure:
    gtk_label_set_text(
        GTK_LABEL( gui->result ),
        "Invalid operand detected"
        );
}

/* -------------------------------------------------
 *
 * -------------------------------------------------
 */
int main( int argc, char *argv[] )
{
    GtkBuilder *builder = NULL;
    GError     *error   = NULL;

    Gui *gui = g_slice_alloc0( sizeof(*gui) );
    if ( NULL == gui ) {
        fputs( "gui allocation failed, bye...\n", stderr );
        return 1;
    }

    gtk_init( &argc, &argv );

    /*
     * Read glade file into builder
     */

    builder = gtk_builder_new();
    if( !gtk_builder_add_from_file( builder, "zub.glade", &error ) ) {
        g_warning( "%s", error->message );
        g_free( error );
        g_object_unref( G_OBJECT(builder) );
        return 1;
    }

    /*
     * Populate our GUI from builder (unref builder when done)
     */

    gui->window = GTK_WIDGET(
            gtk_builder_get_object( builder, "windMain" )
            );
    gui->op1    = GTK_WIDGET(
            gtk_builder_get_object( builder, "teOp1" )
            );

    gui->op2    = GTK_WIDGET(
            gtk_builder_get_object( builder, "teOp2" )
            );
    gui->ok    = GTK_WIDGET(
            gtk_builder_get_object( builder, "buttonOk" )
            );
    gui->result = GTK_WIDGET(
            gtk_builder_get_object( builder, "labelResult" )
            );
    g_object_unref( G_OBJECT( builder ) );

    /*
     * Connect callback functions to signals
     */

    g_signal_connect(
        gui->window,
        "destroy",
        G_CALLBACK( gtk_main_quit ),  /* provided by GTK+2 */
        NULL
        );

    g_signal_connect(
        gui->ok,
        "clicked",
        G_CALLBACK( on_clicked_button_ok ),
        gui
        );
    

    /*
     * Prepare some visuals before drawing the main window
     */

    gtk_window_set_title(
        GTK_WINDOW(gui->window),
        "GTK+2 sample for zub"
        );
    gtk_window_set_position(
        GTK_WINDOW( gui->window ),
        GTK_WIN_POS_CENTER
        );

    gchar *txt = g_strdup_printf( TXTF_RESULT, 0L );
    gtk_label_set_text( GTK_LABEL( gui->result ), txt );
    g_free( txt );

    /*
     * All set... go
     */

    gtk_widget_show( gui->window );
    gtk_main();

    /*
     * Cleanup & exit
     */
    g_slice_free1( sizeof(*gui), gui );
    return 0;
}

Why not just use the Win32 api?
Use something to create/edit a resource file like ResEdit Resource Editor - free resource editor for Win32 and just build what you want.

I agree with directly using the Win32 api, CreateWindowEx() is the function for creating a window, there are a whole bunch of parameters you can pass to this to create specific controls within the window such as WC_LISTVIEWW to create a listview control etc.. You just need to add a callback function and learn a few things about this although it's almost cut and paste stuff.

Here is a tutorial I used to get the basics of win32 - theForger's Win32 API Tutorial

As someone else already did, I suggest that you deal directly with the Win32 API. They allow the creation of very little and fast program files with just a few lines of code (well, in a sense).

Moreover, the web is literally INFESTED with basic tutorials, samples and examples. As a reference material, in my opinion the "official" Win32 Help File is the best option, though to run it in Windows 7 you will need to download a small piece of free software from Microsoft's site.

You can find the Win32 Help File here: http://www.carabez.com/downloads/win32api_big.zip
I think that the help file has been written in the Win '98 system era, but I'm still using its directives today and my programs work fine in Windows 7.

I've only been learning the win32 api for about a week now, but I agree with Elysia. I'm not saying Win32 is bad (I actually like most of it and think it's clever), it is just one of those things where it takes a while to get enough groundwork laid to make things easier (I hope).

It does have really great documentation though.

Originally Posted by Elysia

Win32 is difficult to work with and most tutorials out there are just plain wrong, use insecure practices or both. It is difficult to get Win32 right.
I really suggest you use a good framework, or use a higher-level language for building applications, such as C# (very easy to make apps with on Windows).

I second that (although I don't think that the Win32 API is that difficult... but it surely is more difficult than modern C GUI frameworks such as GTK+).

As I said in a previous post, I believe that if one is forced to use C for GUI apps, then I don't think he/she will find anything better than GTK+.

PS. Vala is a relatively new language that attempts to offer a C#/Java like "experience" when programming GTK+ apps. However, on Windows C# is a much more sane option.

I'm currently taking the GTK+ route.Size of the resulting code is a minor consideration IMO when it gives the ability to create code that will run on several OS, thus widening options in a future in which Windows isn't quite the front runner it was.