lf332, SoftwareDevelopment: Programar Interfaces Gráficas de Usuario - GUI - con GTK

<-- | Hogar | Mapa | Indice | Busqueda

Este documento está disponible en los siguientes idiomas: English Castellano ChineseGB Deutsch Francais Italiano Nederlands Russian Turkce

por Özcan Güngör
<ozcangungor(at)netscape.net>

Sobre el autor:

Actualmente estoy haciendo el servicio militar como administrador Linux, Oracle y programador web.

Traducido al español por:
Carlos González Pérez <carlosdw(en)terra.es>

Contenidos:

Botones Conmutadores
Botones de verificación
Etiquetas
ToolTips
Cuadros Combinados
Formulario de "talkback" para este artículo

Programar Interfaces Gráficas de Usuario - GUI - con GTK - 3ra parte.

Resumen:

En esta serie de artículos, aprenderemos cómo escribir Interfaces Gráficas de Usuario (GUIs) utilizando GTK. No se cuanto se extenderá. Para poder entender estos artículos, debe conocer los siguientes conceptos sobre el lenguaje de programación C:

Variables
Funciones
Punteros

Se recomienda leer los artículos anteriores:
Programar Interfaces Gráficas de Usuario - GUI - con GTK - 1ra parte.,
Programar Interfaces Gráficas de Usuario - GUI - con GTK - 2ra parte.
Este artículo es un poco más corto que los otros porque estoy realizando el servicio militar.

_________________ _________________ _________________

Botones Conmutadores

Este botón tiene la apariencia de un botón común pero tiene dos estados: Pulsado o no. Para crear un botón conmutador se usa una de las siguientes funciones:

GtkWidget *toggle=gtk_toggle_button_new(void);
GtkWidget *toggle=gtk_toggle_button_new_with_label(const gchar *label);

La primera función crea un botón conmutador sin etiqueta de texto, la segunda función crea el mismo botón pero con una etiqueta de texto incorporada.

Puede establecer el estado con la siguiente función:

gtk_toggle_button_set_active (GtkToggleButton *toggle_button, 
                              gboolean is_active);

donde toggle_button es el botón cuyo estado queremos cambiar y is_active es el estado (0 o 1). Cuando es 0, el botón no está pulsado; cuando es 1, el botón está pulsado.

Para averiguar el estado de un botón puede utilizar la siguiente función:

gboolean gtk_toggle_button_get_active(GtkToggleButton *button);

El evento "toggled" puede estar conectado a otro botón.

A continuación se muestra un ejemplo:

#include <gtk/gtk.h>
void togg(GtkWidget *widget, gpointer *data){
   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data)))
    g_print("State is 1\n");
   else
    g_print("State is 0\n");
}

int main( int argc,char *argv[] )
   {
   
   GtkWidget *window;
   GtkWidget *button;

   gtk_init (&argc, &argv);

   /* Create a new window */
   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title (GTK_WINDOW (window), "Toggle Button");

   /* Connect destroy event to the window. */
   gtk_signal_connect (GTK_OBJECT (window), "destroy",
                       GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
   
   /* Creates a toggle button */ 
   button=gtk_toggle_button_new_with_label("I'm a toggle button");
   
   /* Add the button to window */
   gtk_container_add(GTK_CONTAINER(window),button);

   /* Connect "toggled" event to the button */ 
   gtk_signal_connect (GTK_OBJECT (button), "toggled",
                       GTK_SIGNAL_FUNC(togg),(gpointer *)button);

   gtk_widget_show(button);
   gtk_widget_show (window);
   
   gtk_main ();
   return(0);
}

Botones de verificación

Los botones de verificación (también llamados casillas de verificación) son una subclase del botón de conmutación. Se puede utilizar para seleccionar opciones.

Para crear un botón de verificación se usa la siguiente función:

GtkWidget* gtk_check_button_new (void);
GtkWidget* gtk_check_button_new_with_label (const gchar *label);

Las explicaciones son las mismas que para el botón de conmutación.

Ejemplo:

#include <gtk/gtk.h>
void togg(GtkWidget *widget, gpointer *data){
   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data)))
       g_print("State is 1\n");
   else
    g_print("State is 0\n");
}

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

    GtkWidget *window;
    GtkWidget *button;

    gtk_init (&argc, &argv);
    
    /* Create a new window */
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title (GTK_WINDOW (window), "Check Button");

    /* Connect destroy event to the window. */
    gtk_signal_connect (GTK_OBJECT (window), "destroy",
                        GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
   
    /* Creates a check button */ 
    button=gtk_check_button_new_with_label("I'm a check button");
   
    /* Add the button to window */
    gtk_container_add(GTK_CONTAINER(window),button);

    /* Connect "toggled" event to the button */ 
    gtk_signal_connect (GTK_OBJECT (button), "toggled",
                        GTK_SIGNAL_FUNC(togg), (gpointer *)button);
    gtk_widget_show(button);
    gtk_widget_show (window);
   
    gtk_main ();
    return(0);
}

Etiquetas

Las etiquetas nos permiten poner cualquier texto en una ventana. Para crear una etiqueta, simplemente use la siguiente función:

GtkWidget* gtk_label_new(const gchar *text);

Con la función:

gtk_label_set_text(GtkLabel *label, gchar *text);

puede cambiar la cadena de texto de una etiqueta cuando lo desee.

gtk_label_set_justify(GtkLabel *label, GtkJustification jtype);

La función gtk_label_set_justify se usa para justificar el texto de la etiqueta . jtype puede ser:

GTK_JUSTIFY_LEFT para justificar a la izquierda,
GTK_JUSTIFY_RIGHT para justificar a la derecha,
GTK_JUSTIFY_CENTER para centrar el texto,
GTK_JUSTIFY_FILL to para que el texto cubra toda la etiqueta.

gtk_label_set_line_wrap (GtkLabel *label,gboolean wrap);

se usa para partir el texto en tantos trozos como sea necesario cuando la longitud del texto supera un límite. Cuando wrap vale 1, el texto que excede se pasa a la siguiente línea si no vale 1 no se comporta de esta forma.

gtk_label_get(GtkLabel *label, gchar **str)

se usa para tomar el texto de la etiqueta y depositarlo en str.

ToolTips

Tooltip es el texto que aparece cuando el ratón esta sobre un widget. Por ejemplo, se puede establecer un tip para un botón y el texto "enviar la información" aparezca cuando el ratón este sobre él.

Para hacer esto se debe crear un widget GtkToolTips:

GtkToolTips* gtk_tooltips_new();

Entonces este tooltip se añade al widget:

gtk_tooltips_set_tip(GtkTooltips *tooltips, GtkWidget *widget, 
                     const gchar *tip_text,const gchar *tip_private);

Un pequeño ejemplo:

#include <gtk/gtk.h>
int main( int argc,char *argv[] )
{
    GtkWidget *window;
    GtkWidget *button;
    GtkTooltips *tip;
    
    gtk_init (&argc, &argv);

    /* Create a new window */
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title (GTK_WINDOW (window), "Tooltips");

    /* Connect destroy event to the window. */
    gtk_signal_connect (GTK_OBJECT (window), "destroy",
                        GTK_SIGNAL_FUNC (gtk_main_quit), NULL);

    /* Creates a button */
    button=gtk_button_new_with_label("I'm a Button");

    /* Add the button to window */
    gtk_container_add(GTK_CONTAINER(window),button);

    /* Creates a tooltips*/
    tip=gtk_tooltips_new();

    /* Attache this tooltips to button with text*/
    gtk_tooltips_set_tip(tip, button, "Click me!",NULL);

    gtk_widget_show(button);
    gtk_widget_show (window);

    gtk_main ();
    return(0);
}

Otras funciones:

gtk_tooltips_enable (GtkTooltips *tooltips);

Activa los tooltips.

gtk_tooltips_disable (GtkTooltips *tooltips);

Desactiva los tooltips.

Para capturar cualquier dato de tooltip de un widget necesitaremos:

GtkTooltipsData* gtk_tooltips_get_data(GtkWidget *widget);

GtkTooltipsData es una estructura con la siguiente forma:

struct _GtkTooltipsData
{
   GtkTooltips *tooltips;
   GtkWidget *widget;
   gchar *tip_text;
   gchar *tip_private;
   GdkFont *font;
   gint width;
   GList *row;
};

Para establecer el retardo con el que aparece el texto, tenemos:

gtk_tooltips_set_delay (GtkTooltips *tip, guint delay)

Cuadros Combinados

Un cuadro combinado es una caja que muestra una lista de opciones en un menú desplegable, de las cuales una de ellas puede ser seleccionada.

Se puede crear un cuadro combinado con

GtkWidget *gtk_combo_new();

Y necesitaremos que se pase la lista de opciones como una estructura del tipo GList.

GList *glist=NULL;

Las opciones se pueden añadir a la lista con:

GList *g_list_append(GList *list, gchar *option);

Luego se añade la lista al cuadro combinado con:

gtk_combo_set_popdown_strings(GtkCombo *combo, GList *List);

El cuadro combinado está preparado. Para leer la opción seleccionada utilizamos:

gchar *gtk_entry_get_text(GtkEntry *entry);

entry es GTK_ENTRY(GTK_COMBO(combo)->entry)) en este caso.

gtk_combo_set_use_arrows(GtkCombo *combo,gint val);

esta función se utiliza para activar o desactivar las teclas de "subir y bajar" en un cuadro combinado, cuando val es 0, están desactivadas, de otro modo estas teclas cambian el valor. Pero cuando el valor en un cuadro combinado es diferente a los valores de la lista, estas teclas no funcionan.

gtk_combo_set_use_arrows_always(GtkCombo *combo,gint val);

Esta función es lo mismo que gtk_combo_set_use_arrows pero cuando el valor en el cuadro es diferente a los valores de la lista, las teclas funcionan.

gtk_combo_set_case_sensetive(GtkCombo *combo, gint val);

Cuando val es 1, se puede introducir un valor en la lista.

#include <gtk/gtk.h>
void act(GtkWidget *widget, gpointer *data){ 
   g_print((gchar *)data);
}

int main( int argc,char *argv[] ) {
   GtkWidget *window;
   GtkWidget *combo;
   GtkWidget *button;
   GtkWidget *box;
   GList *list=NULL; 

   list=g_list_append(list,"Slackware");
   list=g_list_append(list,"RedHat");
   list=g_list_append(list,"SuSE");

   gtk_init (&argc, &argv); 
   
   /* Create a new window */
   window = gtk_window_new (GTK_WINDOW_TOPLEVEL); 
   gtk_window_set_title (GTK_WINDOW (window), "Combo Box");
   
   /* Connect destroy event to the window. */
   gtk_signal_connect (GTK_OBJECT (window), "destroy",
                       GTK_SIGNAL_FUNC(gtk_main_quit), NULL); 
   
   /* Create a new horizontal box */
   box=gtk_hbox_new(1,0);
   gtk_container_add(GTK_CONTAINER(window),box);
   
   /* Creates a combo box */ 
   combo=gtk_combo_new();

   /* Sets the list */
   gtk_combo_set_popdown_strings(GTK_COMBO(combo),list);

   /* Enables up/down keys change the value. */
   gtk_combo_set_use_arrows_always(GTK_COMBO(combo),1);

   gtk_box_pack_start(GTK_BOX(box), combo,1,1,1); 

   button=gtk_button_new_with_label("Write it");
   gtk_signal_connect(GTK_OBJECT(button),"clicked",GTK_SIGNAL_FUNC(act), 
             gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(combo)->entry)));
   gtk_box_pack_start(GTK_BOX(box), button,1,1,1);

   gtk_widget_show(box);
   gtk_widget_show(combo);
   gtk_widget_show(button); 
   gtk_widget_show (window);
   
   gtk_main ();
   return(0);
   }

Todos los comentarios serán bien recibidos.

Formulario de "talkback" para este artículo

Cada artículo tiene su propia página de "talkback". A través de esa página puedes enviar un comentario o consultar los comentarios de otros lectores

Ir a la página de "talkback"

<--, regresar al índice de este número

Información sobre la traducción:

tr --> -- : Özcan Güngör <ozcangungor(at)netscape.net>

en --> tr: Özcan Güngör <ozcangungor(at)netscape.net>

en --> es: Carlos González Pérez <carlosdw(en)terra.es>

2004-03-19, generated by lfparser version 2.41