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 que se usa para crear interfaces gráficas. Bueno, gnome la usa, pero eso no significa que solo se pueda usar en el entorno gnome siempre que la biblioteca GTK esté instalada en el sistema (básicamente un sistema de gráficos). p>
Tanto los ordenadores como los ordenadores los tienen) pueden ejecutar programas basados en GTK Además de plataformas tipo UNIX, también ha sido portado
a Windows, y también existen programas para dispositivos integrados. versión framebuffer, etc.
GTK se basa en dos bibliotecas importantes. Una es GLib, que no es una biblioteca de gráficos y es diferente de glibc.
Generalmente proporciona algunas interfaces para proteger. diferencias entre sistemas, por ejemplo, gint es siempre de 32 bits
, etc., el otro es GDK, que es una biblioteca de gráficos independiente del dispositivo que admite puntos de dibujo básicos, y
Para tareas como comunicarse con el administrador de ventanas, dado que GTK está diseñado para usarse en varias plataformas, no solo en el entorno XWindow, esta biblioteca también es necesaria y el GTK encima de ellas La biblioteca proporciona.
algunos widgets: pueden entenderse como controles, pero la ventana también es un widget,
que podemos usar y proporciona eventos bien empaquetados.
*** Conceptos básicos de desarrollo GTK+
Para desarrollar software basado en GTK, primero debe instalar el paquete de desarrollo GTK+. Compruebe si está instalado correctamente
El método. es ejecutar ``pkg-config --cflags --libs gtk+-2.0'' después de la instalación. Si la instalación es incorrecta
le indicará que no se puede encontrar el paquete correspondiente.
GTK en sí es una biblioteca basada en C. Por supuesto, hay envoltorios en lenguajes como C ++, pero todo su sistema está orientado a objetos. Su clase más básica es GObject, GtkObject lo hereda y GtkObject es. también deriva
el GtkWidget que usamos con más frecuencia, y todos los controles de formulario que usamos se derivan de él. Por lo tanto,
en el entorno C tenemos que manejar estas clases manualmente. , GTK y el GLib subyacente proporcionan un método de conversión unificado. Por ejemplo, para convertir un botón de tipo GtkWidget* en una forma GtkButton, el método de escritura es: GTK_BUTTON(botón), solo Jiangzi.
Yo soy. No voy a incluir una página GTK hello world aquí. Puedes encontrar este programa simplemente buscando en Google.
Podemos pensar en cómo construir una interfaz gráfica.
Primero necesitamos inicializar. GTK proporciona gtk_init() como inicialización, que verifica algunas partes específicas de los parámetros del programa
y realiza sus propias configuraciones. El método de llamada es el siguiente:
<. p>gtk_init(&argc, &argv);El propósito de pasar punteros a argc y argv es que gtk_init los procese y use el propio GTK
Extraiga algunos parámetros utilizados.
A continuación, debemos crear estos controles. En GTK, al crear un control se devolverá un
tipo GtkWidget (o su clase derivada), el formato de todas las funciones que crean controles es
.gtk_control type_new (lista de parámetros). Por ejemplo, para crear una ventana.
El método de escritura es:
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
Luego, debemos configurar la función de respuesta al evento. El evento en GTK se llama respuesta de evento GTK.
La interfaz de la función debería ser similar a esta
void
destroy(GtkWidget *widget, gpointer data)
Lo conectamos a un control El método es así
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(destroy), NULL);
Debería ser fácil de entender.
El Dongdong que creamos necesita explicar su posición y relación de inclusión. GTK usa contenedores para resolver este problema
Puede garantizar que la ubicación de los controles siga siendo razonable cuando se amplía la ventana. Uso específico
No entraré en detalles. A menudo tengo que lidiar con contenedores más adelante, pero básicamente no necesito preocuparme por el código C, eh
. de hecho, cualquiera de nuestros controles visuales hereda de los contenedores. Por ejemplo, el botón también es un
contenedor. A menudo se instala con un GtkLabel, que es un control utilizado para mostrar texto sin formato. >
Entonces podemos ver un botón de texto. Hmm. El método para usar el contenedor es el siguiente.
gtk_container_add(GTK_CONTAINER(window), button);
De esta manera. , el botón ocupará toda la ventana de control. Veremos más adelante que podemos usar
GtkVBox, GtkHBox y otros contenedores para separar los formularios.
Bien, ya estamos listos para iniciar el. programa Podemos usar gtk_widget_show() para mostrar cada
control, luego debemos ingresar al llamado ciclo de respuesta de eventos, que requiere el uso de gtk_main().
Durante la ejecución de. En el programa, necesitamos manipular el control, por ejemplo, necesitamos controlar la entrada en un control de entrada (cuadro de texto
), esta operación se completa usando la forma de gtk_control type_action (objeto, parámetro)
, como la tarea que acabamos de mencionar, el método es gtk_entry_get_text(entry).
Por cierto, hablemos de la salida del programa GTK. Cerrar la ventana GTK (incluso. todas las ventanas) no significa que el programa se cierre, porque al final es solo una interfaz. Por supuesto que podemos usar el método de autodestrucción de exit() para salir,
pero es mejor. dale a GTK la oportunidad de encargarse de las consecuencias. En la carta de respuesta del evento de destrucción de la ventana principal
Simplemente usa gtk_main_quit() para los números.
El método para compilar programas GTK es. también muy simple.
gcc -o foo foo.c `pkg-config --cflags - -libs gtk+-2.0`
** Utilice Glade para personalizar rápidamente la interfaz de usuario
Vale, he dicho muchas cosas, si hablo de lo que dije arriba no utilizamos
la mayor parte del montón, ¿no crees que es una pena? La introducción anterior es solo para brindarle algunos conceptos básicos
de la biblioteca GTK. Los conceptos están bien, realmente no necesitamos usarlos para programar. Piénselo, una interfaz más complicada. /p>
con más de una docena de controles, además de varios contenedores, y cuelga eventos por tu cuenta Además de un destino extraordinario
p>
El nombre da miedo con solo pensarlo.
En este momento, nació Glade. Este es un editor de interfaz visual, ¡pero es solo uno!
Es solo un editor de interfaz, ni siquiera se proporciona un cuadro de edición de código. Ignórelo por ahora, abra Glade (se omite la instalación, perdóneme, recuerde instalar libglade-dev), debería estar bien. Entendido, puede crear un. interfaz con solo unos pocos clics
, luego seleccione la señal requerida en la columna de señal de la ventana de propiedades y configure la función de respuesta, es muy fácil
hacer
.Después de jugar unos minutos, surge la pregunta, ¿cómo convertirlo en un programa IDE que brinde funciones similares como
Borland C++ Builder, cuando hacemos clic para crear un nuevo control, lo hacemos? Puede ver el código generado automáticamente incluso en la ventana de código. Glade también puede usar este formulario después de diseñar la interfaz y guardarla, haga clic en el botón Generar en la ventana principal, generará automáticamente el código de la interfaz. para escribirlo usted mismo, abra el directorio de código
, ya hay una función vacía para la respuesta de evento creada automáticamente en callbacks.c, complete el procesamiento y luego
Simplemente configure make. después.
Sin embargo, todavía hay problemas con este método de desarrollo. En primer lugar, el código generado automáticamente es muy complicado, pero muchas veces
Todavía no podemos ignorarlo por completo y procesarlo. y la interfaz se mezclan y resulta difícil entenderlos
; en segundo lugar, debido a las razones anteriores, modificar la interfaz se vuelve muy doloroso. En tercer lugar, genera un montón de archivos de configuración que hay allí;
Puede que no sea lo que desea.
Así que glade proporciona otro método. El archivo .glade editado por glade es un documento XML.
De hecho, lo es. ha descrito completamente la interfaz. ¿Podemos cargarla y configurarla directamente de una manera simple?
De esta manera, en nuestro código realmente elimina el molesto código de generación de interfaz y se centra en la parte de procesamiento.
libglade proviene de esto y puede completar muy bien el trabajo mencionado anteriormente. Cuando usamos
glade para crear una interfaz .glade, podemos usar este método para crear la interfaz y. ejecuta el programa
.
#include
#include
GladeXML *GUI;
int
main(int argc, char **argv)
{
gtk_init(&argc, &argv) ;
/* cargar la interfaz */
GUI = glade_xml_new("frame.glade", NULL, NULL);
/* conectar las señales en la interfaz */
glade_xml_signal_autoconnect(GUI);
/* inicia el bucle de eventos */
gtk_main();
regresar 0;
}
El resto es simple, si el control en el que se hace clic en tu botón tiene una función de respuesta
on_button_clicked, escribes
void
on_button_clicked(GtkWidget *widget, datos del gpointer)
{
// balabalabala
}
Eso es todo. Por lo tanto, el conjunto de métodos para crear interfaces mencionados anteriormente en realidad no son necesarios la mayor parte del tiempo. /p>
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`
** Ejemplo de desarrollo
Un programa muy simple, utilizado en el algoritmo de cifrado simétrico criptográfico. Si es una interfaz, son tres textos.
Este cuadro: texto sin formato. contraseña, texto cifrado, tres botones, cifrado, descifrado, claro, terminado Para experimentar con muchos algoritmos, agregamos una ventana desplegable para seleccionar algoritmos. Lo diseñé como un contenedor
Y el marco. , no implementa ningún algoritmo, solo obtiene la entrada del usuario en la interfaz, llama a programas externos y muestra los resultados. De esta manera, se puede utilizar la implementación real del algoritmo El programa de interfaz de texto escrito en. C puro está completo.
Es muy conveniente trasplantar. Simplemente haga la misma interfaz que el front-end en Windows y todo se trasplantará.
Entonces, la ventana que tenemos. need Los elementos del cuerpo son GtkEntry, GtkComboBoxEntry y GtkButton Consulte el
manual. Las únicas funciones relacionadas con la interfaz que utilizamos son las siguientes:
- gtk_entry_get_text(), utilizada para obtener. el cuadro de texto Entrada
- gtk_entry_set_text(), usado para mostrar resultados en un cuadro de texto
- gtk_combo_box_get_active_text(), usado para recuperar en ComboBoxEntry (derivado de
ComboBox) El algoritmo seleccionado por el usuario.
Otro problema es que todos necesitan los punteros de objeto correspondientes como parámetros. ¿Cómo obtener esto? Usamos glade_xml_get_widget(GUI, "Nombre de control") para obtener el control. .