GTK in C++: Changing a Label based on console input

Question

To demonstrate what I mean, I wrote up this code without most of the gtk mess:

//more gtk declaration stuff above
int access;
access = 0;

int tries;
tries = 0;

string input;
input = "";

string code;
code = "";

while(access != 1 && tries < 4){
    directions((gpointer)lbl); //change label to "type 'finger'"
    cin >> input;

    if(input.compare("finger") = 0){
        while(code.compare("1") != 0 && tries < 4){
            fpcheck((gpointer)lbl); //change label "Enter the secret code ('1')"
            cin >> code;
            if(code.compare("1") != 0){
                retry((gpointer) lbl);//change label "Try again!"
                tries ++;       
            }
            else{
                fprecog((gpointer) lbl); //change label "Recognized!"
                access = 1;
            }
        }
    }
}
if(access = 1)
    //change label "Access Granted!"
else
    //change label "No access."

gtk_main();
return 0;

Clearly this won't exactly work, since gtk_main() isn't called to the end. The console stuff will run fine, but the window won't pop up until the very end so the user won't know what to do, and if I put gtk_main() early on, the program is stuck in the gtk_main() loop so nothing will happen.

How is this sort of flow typically accomplished in GTK? I've tried some gtk_thread stuff to break out of main, but that's apparently deprecated so I'm trying not to use that.

The input has to be read by a thread that's not gtk_main(), since the input isn't coming from the GUI. In reality, it'll be a device plugged into a beaglebone black, but I think this is a simpler similar situation.

The actual input methods that will be used are 1) a finger print sensor that does actions based on sent and received bytes through a UART channel, and 2) a usb camera and facial recognition scripts using OpenCV methods on a BeagleBone Black running Debian, networked to a laptop to do the intensive opencv stuff. For the moment I'm just trying to get it going with the FP sensor. With our interface, we can call an FP sensor method, which returns an int, and do something depending on that int.

I need to be able to change the GTK label depending on what int is returned, then call another method after the label displays.

Here's a snippet of what the code I'm trying to integrate with looks like:

while(key != 'x')
    {
        imshow("main_display", welcome);
        key = waitKey(1);  //poll keyboard at active screen

        //key = getkey();  //TODO: poll from TFT instead

        switch(key)
        {
            case 'i': //Identify User
                imshow("main_display", press_finger);
                waitKey(1);
                printf("\n---IDENTIFY USER---\n");
                post_log(1, 0);

                do_reg = true;
                Ret = GT_LED_On(LS);
                printf("\nPress Finger");

                //something to force console text before loop starts...?

                Timer.InitTimer();
                while(GT_IsPressFinger(LS) == 0 && ((Timer.ElapsedTime_ms() < TIMEOUT))) {}
                if(Timer.ElapsedTime_ms() >= TIMEOUT)
                {
                    printf("\nCapture TIMEOUT\n");
                    Ret = GT_LED_Off(LS);
                    post_log(6, user_id);
                    imshow("main_display", fps_timeout);
                    waitKey(1000);
                    do_reg = false;
                    break;  //??????????????????????????? GOTO???
                }
                printf("\nCapturing...Standby...\n");
                imshow("main_display", hold_finger);
                waitKey(1);
                Ret = GT_CaptureFinger(LS, 0);

Basically instead of the imshow() we're trying to use an actual GUI framework, and since the device already has GTK going due to OpenCV, it would be nice to stick with GTK. This console question is trying to figure out how to replace imshow() with a label change of a gtk window in a simple context.

Answer 1

I think what you're looking for is Glib IO Channel. If you tie this to the standard input file descriptor, the signal gets fired when the user hits enter. Then you should be able to use cin to get the text.

If your intent is to get some type of password you might instead consider using a dialog to capture user input.

Answer 2

Alright, with the help of Blake I think I found a solution, but I don't know if its the best one.

In order to get the input while gtk_main() was happening, and call a function when that happens, I added a glib io call on the standard input file descriptor to detect cin style input. I used my other code as the callback function. Thanks Blake for the help with this part.

Then, in order to actually update the text in this new mini-thread, I made an update() function to call main_iteration(), while loops through gtk_main() once. Here's documentation on that. I don't know if this is safe usage or if there is a nicer solution, but the program now does what I wanted it to do.

Here's the full code for future reference.

#include <gtk/gtk.h>
#include <unistd.h>
#include <stdio.h>
#include <iostream>
#include <string>
#include <glib.h>


using namespace std;

void update(){
while (gtk_events_pending ())
gtk_main_iteration ();}

void fpcheck(/*GtkWidget *widget, GdkEvent *event,*/ gpointer window) {
    gchar const *text = "<span font='32' weight='bold' color='#DDDDDD'>Enter the Secret\nCode. ('1')</span>";
    gtk_label_set_markup(GTK_LABEL(window), text);
}

void fprecog(/*GtkWidget *widget, GdkEvent *event,*/ gpointer window) {
    gchar const *text2 = "<span font='32' weight='bold' color='#DDDDDD'>Fingerprint Recognized!</span>";
    gtk_label_set_markup(GTK_LABEL(window), text2);
}

void directions(/*GtkWidget *widget, GdkEvent *event,*/ gpointer window){
    gchar const *text3 = "<span font='32' weight='bold' color='#DDDDDD'>Type 'finger'.</span>";
    gtk_label_set_markup(GTK_LABEL(window), text3);
}

void retry(/*GtkWidget *widget, GdkEvent *event,*/ gpointer window){
    gchar const *text4 = "<span font='32' weight='bold' color='#DDDDDD'>Try Again.</span>";
    gtk_label_set_markup(GTK_LABEL(window), text4);
}

void accessed(/*GtkWidget *widget, GdkEvent *event,*/ gpointer window){
    gchar const *text5 = "<span font='32' weight='bold' color='#DDDDDD'>Access Granted!</span>";
    gtk_label_set_markup(GTK_LABEL(window), text5);
}

void denied(/*GtkWidget *widget, GdkEvent *event,*/ gpointer window){
    gchar const *text6 = "<span font='32' weight='bold' color='#DDDDDD'>Access Denied.</span>";
    gtk_label_set_markup(GTK_LABEL(window), text6);
}


gboolean callback(GIOChannel *gio, GIOCondition condition, gpointer lbl){
    int access;
    access = 0;

    int tries;
    tries = 0;

    string input;
    input = "";

    string code;
    code = "";

    while(access != 1 && tries < 4){
        directions((gpointer)lbl); //change label to "type 'finger'"
        update();
        cin >> input;

        if(input.compare("finger") == 0){
            while(code.compare("1") != 0 && tries < 4){
                fpcheck((gpointer)lbl); //change label "Enter the secret code ('1')"
                update();
                cin >> code;
                if(code.compare("1") != 0){
                    retry((gpointer) lbl);//change label "Try again!"
                    update();
                    tries ++;       
                }
                else{
                    fprecog((gpointer) lbl); //change label "Recognized!"
                    update();
                    access = 1;
                }
            }
        }
    }
    if(access == 1)
        accessed((gpointer)lbl);
        //change label "Access Granted!"
    else
        denied((gpointer)lbl);
        //change label "No access."
}


int main(int argc, char *argv[]){

    GtkWidget *window; //main window
    GtkWidget *lbl; //text
    GdkColor color = {0, 0x0, 0x0, 0x0}; //window color

    gtk_init(&argc, &argv);

    window = gtk_window_new(GTK_WINDOW_TOPLEVEL); //init window
    //gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); //window pos on screen
    gtk_window_set_resizable(GTK_WINDOW(window), FALSE); //user cant resize //doesnt work
    //gtk_window_set_default_size(GTK_WINDOW(window), 800, 480); //window size

    gtk_widget_modify_bg(window, GTK_STATE_NORMAL, &color); //set color to window
    gtk_window_set_decorated(GTK_WINDOW(window), FALSE); //borderless
    gtk_widget_show(window);

    lbl = gtk_label_new(NULL); //label init
    gtk_container_add(GTK_CONTAINER(window), lbl);
    gtk_widget_set_size_request(lbl,800,480); //sets area that text can be //breaks alignment
    gtk_misc_set_alignment(GTK_MISC(lbl), .5, .5); //alignment
    gtk_label_set_line_wrap_mode(GTK_LABEL(lbl), PANGO_WRAP_WORD_CHAR); //sets line wrap on

    gchar const *str = "<span font='32' weight='bold' color='#DDDDDD'>Press Enter to begin.</span>"; //label text, uses pango markup
    gtk_label_set_markup(GTK_LABEL(lbl), str); //add pango str to label
    gtk_label_set_angle(GTK_LABEL(lbl), -90);

    gtk_widget_show(lbl);

    //fpcheck((gpointer)lbl);
    //g_signal_connect(G_OBJECT(window), "key-press-event", G_CALLBACK(fpcheck), (gpointer) lbl); //calls fpcheck to change label 
    //g_signal_connect(G_OBJECT(window), "key-release-event", G_CALLBACK(fprecog), (gpointer) lbl);     
    //fprecog((gpointer)lbl);

    g_signal_connect(G_OBJECT(window), "destroy",
    G_CALLBACK(gtk_main_quit), NULL);

    //gtk_widget_show_all(window); //build the window all at once

    //label says "Ready"

    GIOChannel *gio;
    gio = g_io_channel_unix_new(STDIN_FILENO);
    guint ret;
    ret = g_io_add_watch(gio, G_IO_IN, callback, (gpointer)lbl);

    gtk_main();

    return 0;
}