Cómo utilizar gtk para desarrollar aplicaciones de interfaz gráfica en Linux

*Utilice GTK y Glade para desarrollar rápidamente interfaces gráficas de Linux.

* *Introducción a GTK

* * *Conceptos básicos

GTK es una biblioteca para la creación de interfaces gráficas. Bueno, esto es lo que usa gnome, pero no es sólo esto.

Sólo se puede utilizar en el entorno gnome, siempre y cuando esté instalada la biblioteca GTK en el sistema (básicamente hay dos sistemas gráficos)

Puedes ejecutar programas basados ​​en GTK . Además de las plataformas tipo UNIX, también se ha adaptado.

En Windows, existen versiones de framebuffer para dispositivos integrados, etc.

GTK se basa en dos bibliotecas importantes. Uno es GLib, que no es una biblioteca de gráficos, a diferencia de GLBC.

En general, proporciona algunas interfaces para proteger las diferencias del sistema, como que gint sea de 32 bits en todas partes.

Sí, y así sucesivamente; el otro es GDK, que es una biblioteca de gráficos independiente del dispositivo que admite puntos de dibujo básicos

Comunicación con el administrador de ventanas y otras tareas, porque GTK es diseñado para usarse en una variedad de plataformas, no solo .

Entorno XWindow, por lo que esta biblioteca también es necesaria. La biblioteca GTK se mencionó anteriormente.

Para algunos widgets, pueden entenderse como controles, pero aquí la ventana también es un widget.

Utilizamos y proporcionamos un mecanismo de respuesta a eventos bien empaquetado.

*** GTK Development Foundation

Para desarrollar software basado en GTK, primero debe instalar el paquete de desarrollo GTK. Compruebe si está instalado correctamente.

El método es, si la instalación es incorrecta, ejecutar ""pkg-config-cflags-libsgtk -2.0" después de la instalación.

De hecho, le indicará que el paquete correspondiente no puede ser encontrado

GTK en sí es una biblioteca basada en C y, por supuesto, existen lenguajes como C wrap, pero todo su sistema está orientado a la superficie

Su clase base. es gobject. , GtkObject hereda, GTKObject deriva.

Muestra nuestro GtkWidget más utilizado, todos los controles de formulario que utilizamos se derivan de él.

En el entorno C, usamos estos. Las conversiones de clases deben manejarse manualmente. GTK y su simplista proporcionan una forma de unificar conversiones, como botones de tipo GtkWidget* en formas GtkButton

La escritura es: GTK _ BUTTON

<. p>No voy a enumerar la página Hola mundo de GTK. Este programa solo se puede encontrar en Google. Podemos pensar en cómo crear una interfaz gráfica nosotros mismos.

Primero, debemos inicializar GTK. proporciona gtk_init() como inicialización, que verifica los parámetros del programa en algunas partes específicas de su propia configuración. El método de llamada es el siguiente:

GTK_init(amp;argc amp;argv);

<. p>El propósito de pasar argc y argv a punteros es que gtk_init los procese y coloque el propio gtk

Extraiga algunos de los parámetros utilizados

Luego tenemos que crear los controles. en GTK.

Apunta al GtkWidget. Un puntero a un tipo (o su clase derivada). El formato de todas las funciones que crean controles es

Gtk_control_type_new (lista de parámetros).

Por ejemplo, el método para crear una ventana es:

widget GTK * WINDOW = GTK _ WINDOW _ new (GTK _window_top nivel

Luego, debemos configurar la respuesta del evento; función. Los eventos GTK se denominan respuestas de eventos de señal. GTK.

La interfaz de la función debería verse así.

Vacío

Destruir(GtkWidget *widget, gpointer data)

La forma en que lo conectamos al control es esta.

G_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(destroy), NULL);

Debe ser fácil de entender.

Creamos el producto "Knock Knock" para explicar sus relaciones de ubicación e inclusión. GTK soluciona este problema con los contenedores.

Una pregunta: puede garantizar que la ubicación del control siga siendo razonable cuando se escala la ventana y el contenedor es específico.

No sé cómo usarlo específicamente. A menudo tenemos que lidiar con contenedores más adelante, pero básicamente no tenemos que preocuparnos por el código C.

Sin embargo, de hecho, cualquiera de nuestros controles visuales se hereda de los contenedores, como los botones.

El contenedor suele estar cargado con GtkLabel, que es un control utilizado para mostrar texto sin formato.

Podemos ver un botón de texto. Bueno, aquí se explica cómo usar contenedores.

GTK _ CONTAINER _ add(GTK _container (ventana), botón);

De esta forma el botón ocupará todo el control de ventana, lo cual veremos más adelante.

GtkVBox, GtkHBox y otras formas independientes del contenedor.

Bien, ya estamos listos para iniciar el proceso. Podemos usar gtk_widget_show() para mostrar cada uno.

Control, entonces debemos entrar en el llamado bucle de respuesta a eventos, que utiliza gtk_main().

En el proceso de ejecución del programa, debemos manipular controles. Por ejemplo, debemos ingresar un control de entrada (cuadro de texto

. Dichas operaciones usan gtk_ tipo de control _ acción (). objeto, parámetro) forma.

Por ejemplo, la tarea que acabamos de mencionar se completa con gtk_entry_get_text(entry).

Por cierto, salir del programa GTK no significa cerrar la ventana GTK (o incluso todas las ventanas) del programa.

Salir, porque al final es solo una interfaz, por supuesto que podemos usar el método de autodestrucción de Exit () para salir.

Fuera, pero sería mejor darle a GTK la oportunidad de manejar las cosas respondiendo al evento de destrucción en la ventana principal.

Simplemente use gtk_main_quit() en el número.

El método de compilación de programas GTK también es muy sencillo.

gcc -o foo foo . c ` pkg-config-cflags-libs GTK -2.0 '

* *Utiliza Glade para personalizar rápidamente la interfaz de usuario.

Vale, dije mucho. Si digo la mayoría de las cosas que dije anteriormente, no lo hacemos.

Lo usaré. ¿Crees que lo siento? La introducción anterior solo le brinda información básica sobre la biblioteca GTK.

Los conceptos, los conceptos son buenos, pero realmente no necesitamos programar con ellos. Piénselo, un límite más complejo.

En la superficie, hay más de una docena de controles, además de varios contenedores, eventos colgados por ti mismo y una vida extraordinaria.

El nombre da miedo sólo de pensarlo.

¡En ese momento nació el claro! Es un editor de interfaz visual, pero es sólo uno.

Es sólo un editor de interfaz, ni siquiera un cuadro de edición de código. No importa, abre el claro (perdóname, recuerda instalar libglade-dev), debería ser fácil de entender y puedes hacerlo con solo unos pocos consejos.

Una interfaz, luego seleccione la señal requerida en la barra de señal de la ventana de propiedades y configure la función de respuesta, lo cual es muy bueno.

Entendido.

Después de jugar unos minutos, surgió la pregunta, ¿cómo convertirlo en un programa? Los IDE que brindan una funcionalidad similar, como Borland C Builder, pueden incluso vernos a nosotros mismos en la ventana de código al hacer clic para crear un nuevo control.

Glade también puede utilizar este formulario para código generado dinámicamente. Después de diseñar la interfaz y guardarla, haga clic en el botón principal.

En la ventana, genera automáticamente el código de la interfaz sin necesidad de escribirlo usted mismo. Abre el código.

En el directorio, callbacks.c ya tiene una función vacía que se crea automáticamente en respuesta al evento. Se completa y procesa, pero

make se puede configurar más adelante.

Sin embargo, todavía existen problemas con este enfoque de desarrollo. En primer lugar, el código generado automáticamente es muy complejo, pero muchas veces todavía no podemos ignorarlo por completo. El procesamiento y las interfaces se mezclan y resulta difícil de entender.

; En segundo lugar, debido a las razones anteriores, modificar la interfaz es doloroso; en tercer lugar, genera un montón de cosas para ti.

Un archivo de configuración faltante no es necesariamente lo que desea.

Por lo tanto, glade proporciona otro método. de. El archivo glade editado por glade es un documento XML.

a. De hecho, la interfaz ha sido completamente descrita. ¿Es posible cargar partidos directamente de forma sencilla?

¿Y qué? Al hacer esto, realmente nos deshacemos del molesto código de generación de interfaz en nuestro código y, en cambio, nos especializamos en él.

Precauciones de tratamiento.

Debido a esto, libglade puede hacer bien el trabajo anterior. Cuando usamos

glade para crear una interfaz . glade, podemos construir la interfaz y ejecutar el programa de esta manera.

Se acabó.

# incluir ltGTK/GTK . h gt;

# incluir ltglade/glade

GladeXML * GUI

( Igual que organizaciones internacionales) Organizaciones internacionales

main(int argc, char **argv)

{

GTK _ init( amp; argc amp; argv);

/*Cargar interfaz*/

GUI = glade_xml_new("frame.glade ", NULL, NULL);

/*Conectar señales en la interfaz* /

glade _ XML _ signal _ auto connect(GUI);

/*Iniciar bucle de eventos*/

GTK _ main(); >

Devuelve 0;

}

Si el control de clic del botón tiene una función de respuesta, el resto es simple.

En _ botón _ hecho clic(GtkWidget * widget, datos de gpointer)

{

//Bala bala bala

}

Eso es bueno. Por lo tanto, la mayoría de los métodos mencionados anteriormente para crear interfaces son realmente innecesarios.

Debido al uso de libglade, nuestro método de compilación se convierte en

gcc-o foo foo . c ` pkg-config-cflags-libs libglade-2.0 '

< p. >* *Ejemplo de desarrollo

Un programa muy simple que utiliza un algoritmo de cifrado simétrico de contraseña. Si es una interfaz, serán tres artículos.

Este cuadro: texto sin formato, contraseña, texto cifrado, tres botones, cifrado, descifrado, texto sin formato, terminado. para muchos experimentos.

Hemos agregado una ventana desplegable para seleccionar un algoritmo. Lo diseñé como un paquete.

Y no implementa ningún algoritmo, simplemente obtiene la entrada del usuario en la interfaz, llama a programas externos y

simplemente muestra los resultados. De esta manera, la implementación real del algoritmo se puede completar con un programa de interfaz de texto escrito en C puro.

Es muy conveniente trasplantar, solo necesita crear la misma interfaz que la interfaz en Windows. y todo el trasplante ha terminado.

Entonces, los elementos de formulario que necesitamos son gtkentry, gtkcombboxentry, gtkbutton, check.

Manualmente, solo usamos las siguientes funciones relacionadas con la interfaz:

-gtk_entry_get_text(), utilizada para obtener entrada de cuadro de texto.

-gtk_entry_set_text() muestra los resultados en un cuadro de texto.

-gtk_combo_box_get_active_text(), utilizado por ComboBoxEntry (derivado de

ComboBox) para recuperar el algoritmo seleccionado por el usuario.

Otro problema es que todos requieren punteros de objeto correspondientes como parámetros. ¿Cómo deberíamos conseguirlos? Hacemos

obtener el control usando glade_xml_get_widget(GUI, "nombre del control").