Programación GNOME en Linux usando GTK+

Transcripción

1 Programación GNOME en Linux usando GTK+ Por Subhasísh Ghosh Traducción al español por Fernando Frias el día 30 de Junio 2002, para La Gaceta de Linux Revisado y corregido por David Sánchez el 4 de Enero de 2003 para Linux-España Este artículo proporciona una visión general de la programación GNOME en Linux usando el toolkit GTK+. Nota Importante: se asume que el lector tiene el conocimiento básico para moverse dentro de Linux, sabe como usar el escritorio GNOME y posee el nivel y experiencia requeridos de programación C y/o C++. El código fuente incluido junto con el texto, ha sido probado en una computadora con la siguiente configuración: Compaq Presario 4010 Series system, 15.5 GB de espacio en disco duro, 96 MB RAM, procesador Intel Celeron a 400 MHz, Red Hat Linux 7.1 kernel: Este artículo ha sido dividido en las siguientes secciones para un fácil entendimiento: 1. Que es GNOME? una introduccion.. 2. La arquitectura GNOME. 3. GTK+ - una introducción. 4. Un programa básico. 5. Señales y Callbacks 6. Contenedores. 7. Botones. 8. Widgets de entrada. 9. Listas y Combos 10. menús y barras de herramientas. 11. Cajas de diálogo. 12. Conclusiones y enlaces para estudio posterior. 1. Que es GNOME? Introducción. Antes de entrar en el excitante mundo de la programación GNOME en Linux, intentemos entender a que se refiere GNOME. GNOME es el acrónimo para "GNU's Not Unix Network Object Model Environment ". Aunque esto suena un poco complicado, GNOME es un proyecto de software con un objetivo simple: proveer a todos los usuarios de Linux, un extremadamente amigable, no obstante poderoso y completo ambiente de programación. GNOME es actualmente el escritorio por defecto instalado en las últimas versiones de las distribuciones Linux Red Hat y Debian.

2 Para información mas específica sobre GNOME y sus varias maravillosas características, asegúrate de revisar el proyecto GNOME en la página la cual proporciona a los lectores abundante información sobre GNOME, incluyendo documentación en línea, noticias y también descargas de archivos binarios así como código fuente de GNOME compatible con la mayoría de los sistemas Linux. Ahora miremos a GNOME desde "el punto de vista del programador", así como desde "el punto de vista del administrador del sistema. La pregunta básica que viene a la mente es: piensan y sienten lo mismo cuando hablan acerca de GNOME?, esto no es fácil de responder, la mayoría de los administradores Linux, son o han sido programadores Linux en el pasado, lo cual, hace bastante difícil el responder a esta pregunta. Para la mayoría de los administradores de sistemas Linux, el ambiente GNOME provee abundantes herramientas que hacen que el trabajo de administración sea muy simple. Por lo pronto, el programador GNOME tiene la responsabilidad de continuar abasteciendo esas facilidades diseñando programas aún mejores. Entonces, están en una perfecta armonía el uno con el otro al grado de que sus respectivas labores se afectan entre sí. Ahora echemos un vistazo mas de cerca a la funcionalidad de Gnome. GNOME es realmente una capa de programación que esta situada entre el sistema X Window(o X) y el software manejador de ventanas. De tal forma que, como se menciono antes, provee a los programadores GUI Linux una enorme funcionalidad a tal grado que pueden diseñar programas basados en Linux. Pero lo mas significante de todo, la razón por la que GNOME es casi indispensable para todos los desarrolladores Linux/Unix, es que GNOME provee a esos desarrolladores, un entorno integrado el cual fue específicamente diseñado para construir aplicaciones de código abierto(open source) con una consistente interfaz gráfica de usuario. El proyecto GNOME comenzó en agosto de Algunos de los fundadores incluidos, entre otros, Peter Mattis, Spencer Kimball, Richard Stallman, y Erik Troan y Mark Ewing de Red Hat, Inc. 2. La arquitectura GNOME. La extremadamente poderosa, sin embargo, flexible arquitectura de GNOME, es lo que proporciona a GNOME su estupenda funcionalidad. El conjunto de herramientas base en GNOME es llamado GTK+(the GIMP toolkit). Fue originalmente escrito para usarse en GIMP (GNU Image Manipulation Program). La adecuada comprensión de GTK+ es extremadamente necesaria para la asimilación de la programación GNOME. GTK+ es un conjunto de herramientas orientadas a objetos, de plataforma cruzada y lenguaje neutral, que es ante todo, usada para crear aplicaciones independientes de GNOME. Entonces la pregunta que viene es: por que fue GTK+ elegido como el conjunto de herramientas(toolkit) para GNOME?, la respuesta es simple, fue por su soporte a muchos lenguajes de programación incluidos C, C++, PERL, Python, ADA etc. Sin embargo, es útil siempre tener en cuenta que GNOME, al igual que GTK+, fue escrito usando C; de tal forma que aquí estaríamos tratando con C únicamente. Otra pregunta que debe surgir en la mente del lector es: que es lo que contienen esas cosas llamadas "Toolkits"?, los toolkits como GTK o Qt(el ambiente KDE esta basado

3 en Qt), son colecciones de widgets. Lo cual nos trae la pregunta que son los "Widgets"? Los Widgets son controles GUI como botones, menús, cajas de diálogo y otros como los objetos relacionados a funciones generales. Esto puede ser comparado con la Active Template Library (ATL 3.0) sobre la plataforma Microsoft, la cual proporciona a los desarrolladores COM(Component Onject Model) con un armazón listo y hecho para crear objetos y componentes COM(ActiveX, EXE's y ActiveX DLL's). 3. GTK+ - Introducción. Ahora demos un vistazo más de cerca a algunas de las características de GTK+: 1. El conjunto de librerías usadas por GTK+: GLIB(libreria GIMP) y GDK(GIMP Drawing toolkit). 2. GLIB define tipos de datos y suministra funciones que tratan con el manejo de errores y rutinas de memoria. 3. GDK es la plataforma dependiente del estrato que esta presente entre la API de gráficos nativa y GTK+. 4. Eso no es todo. GNOME agrega funcionalidad adicional al GTK+ añadiendo un estrato separado de widgets y librerías específicas de GNOME. 5. De este modo, GNOME viene con una arquitectura habilitada con un amplio conjunto de widgets orientados a objetos y llenos de características. 6. Además de la funcionalidad de GTK+, también tenemos los beneficios agregados de una implementación del sistema COBRA llamada ORBit en la arquitectura GNOME, permitiendo que la comunicación de los objetos de software sea fácil y efectiva. 7. GLIB define su propio conjunto de datos básicos. La mayoría son equivalentes a los datos estándar en C. Datos tipo GLIB gchar gshort glong gint gboolean gpointer Datos tipo C char short long int boolean void* 8. Un requerimiento vital para la adecuada comprensión de GTK+, es el concepto de "herencia de widgets". Los widgets en GTK+, pertenecen a una herencia, así que las funciones que son comunes a un conjunto de widgets, necesitan únicamente ser implementados una vez.

4 Por ejemplo, la función gtk_widget_show, esta dirigida a la eliminación de código duplicado, de modo que conduce a un mejor y mas rápido desarrollo de programas. Los nuevos widgets son derivados de los widgets existentes de mayor nivel, de este modo, solo las características únicas de este widget deberán ser escritas por el programador. Por ejemplo, miremos de cerca a esta particular herencia de objetos: GtkObject --> GtkWidget --> GtkContainer --> GtkBin --> GtkWindow --> GnomeApp Así, si miras cuidadosamente, puedes ver que el widget GnomeApp es derivado del de mayor nivel GtkWindow, el cual en sí mismo ha sido derivado del de mayor nivel GtkBin y así sucesivamente. Si tomamos en cuenta las características esenciales de la programación en lenguaje C++, esto nos trae a la memoria el concepto de "Herencia". no es así?, seguramente lo es. Y es en este aspecto de la "herencia de widgets" en el que se incorpora la funcionalidad derivada en GTK+. Demos ahora una breve mirada a las funciones de creación de widgets. Para que estas funciones operen correctamente, primero debemos asegurarnos de tener todas las librerías GTK+ y GNOME instaladas correctamente, otra cosa importante a tomar en cuenta es que la ruta de las librerías debe de ser correcta, hazlo antes de intentar compilar cualquier código fuente. Primero consideremos la función de creación de un widget, gnome_app_new(), esta función, como se muestra, regresa un puntero a GtkWidget, el cual es un widget genérico. Esto posiblemente se muestra como: GtkWidget *ghosh; ghosh = gnome_app_new( ); Debemos notar que esto significa que si queremos llamar a una función especifica de GnomeApp como gnome_app_set_menús(), entonces tenemos que usar una macro para realizar el enlace de desde el tipo GtkWidget a el tipo GnomeApp; lo cual solo es posible ya que GnomeApp es derivada de GtkWidget (observa la herencia mostrada anteriormente). 4. Un programa básico. La mejor forma de aprender la programación Linux es entender el trabajo interno del kernel y haciendo programas por tí mismo. así que, ahora miremos un pequeño programa para entender mejor el tema. Arranca tu sistema en Linux, si estas en el modo CLI(interfaz de linea de comandos), cambia a gnome usando el comando "switchdesk gnome", y el comando "startx" para arrancar en el sistema GUI X window. Una vez dentro del ambiente GNOME, abre una terminal GNOME, crea un archivo llamado myapp.c usando el editor vi y teclea lo siguiente: /* A sample GNOME program Created By: Subhasísh Ghosh Date: 8th August, 2001 */

5 #include <gnome.h> int main(int argc, char *argv[ ]) GtkWidget *ghosh; gnome_init("sample", "0.1", argc, argv); ghosh = gnome_app_new("sample", "My Window"); gtk_widget_show(ghosh); gtk_main(); return 0; Ahora, para compilar el programa myapp.c, asegúrate de teclear bien (toma en cuenta las comillas simples): # gcc myapp.c -o myapp `gnome-config --cflags --libs gnomeui` GNOME viene con un shell script llamado gnome-config que proporciona al compilador los argumentos correctos para la compilación. Una vez compilado, ejecuta el programa usando el comando: #./myapp & y presiona enter. Una ventana vacía aparecerá en la pantalla, la cual puedes mover, ajustar el tamaño, así como cerrar. Ahora miremos detenidamente el código. Al principio, introducimos algunas líneas de comentarios, describiendo el programa, su creador y la fecha de creación, aunque no es necesario, es una buena práctica de programación incluir comentarios a cada programa. Después, incluimos el archivo de cabecera gnome.h, que se encarga de todas las librerías GTK+ y GNOME así como de las funciónes y definiciones necesarias, luego viene "gosh", que es un puntero a GtkWidget, este apuntara a nuestro nuevo objeto ventana. La función gnome_init es entonces llamada, esta inicializa librerías y es usada para un correcto manejo de sesión. La identificación que se le pasa a la función gnome_init es "sample", el número de versión es "0.1" y la usual línea de argumentos de la función main, estos son necesarios para el trabajo interno de GNOME. Luego viene la función gnome_app_new(), que cuando es ejecutada, crea nuestra ventana, esta toma dos argumentos, como se muestra en el código: "sample" y "My Window". "Sample" es el nombre de la aplicacion y "My Window" es el titulo de la ventana. Pero hay que notar que: aunque el nombre de esta función es gnome_app_new(); esta NO crea ningún tipo de nueva aplicación o algo así; crea una ventana top-level, eso es todo. La siguiente función llamada es gtk_widget_show(), la cual hace visible nuestra ventana. Luego viene gtk_main(), la cual es una función muy importante, ya que asegura que funciónes GNOME como son los eventos y pulsaciones de botones sean ejecutados mediante el paso de funcionalidad a GNOME. De esta forma, este es el trabajo interno de nuestro primer programa GNOME.

6 5. Señales y Callbacks. Ahora demos un profundo vistazo dentro del ambiente de programación GNOME: "Señales" y "Callbacks". Que son y para que se usan?, realmente los necesitamos?, cada vez que el ratón se mueve, entra y sale de widgets, cuando botones son pulsados, o activados y acciones como estas son realizadas, una señal (signal) es enviada a la aplicación. Esta señal puede ser pasada a una función callback. De esta forma, aunque no siempre, las aplicaciones necesitan conectar esos eventos para tomar ciertas acciones. En GTK+/GNOME, llamamos la una función gtk_signal_connect para conectar señales y manejar funciones. La función gtk_signal_connect tiene los siguientes 4 parámetros: 1. GtkObject *object -- El widget al cual un callback es asociado. 2. const gchar *name -- La señal a ser tratada. 3. GtkSignalFunc func -- La función que es llamada cuando la señal es enviada. 4. gpointer data -- Cualquier dato arbitrario que es dado a la función que maneja la señal. Se debe notar que distintos tipos de widgets emiten señales diferentes. Las señales de los botones son: 1. clicked -- botón pulsado (pulsado y liberado). 2. pressed -- botón presionado hacia abajo por el ratón. 3. released -- botón liberado. 4. enter -- Movimiento del ratón dentro del área del botón. 5. leave -- Movimiento del ratón fuera del área del botón. Examinaremos que las Señales y Callbacks juegan un rol vital en las aplicaciones que desarrollaremos mas tarde. 6. Contenedores. A continuación, veremos otro componente vital de la programación GNOME: contenedores. GTK+ utiliza una gran cantidad de contenedores, debido a que GTK+ es realmente un conjunto de herramientas basado en contenedores, lo que significa que tenemos un contenedor padre dentro del cual tenemos que ubicar nuestros widgets. Las ventanas son simples contenedores de widgets. De tal manera que, el punto importante a tomar en cuenta es que GTK+ utiliza "cajas empaquetadas" invisibles las cuales pueden contener múltiples widgets para crear diseños de ventana. Estas "cajas empaquetadas" son de dos tipos: horizontales y verticales, creadas usando la funcionalidad de las funciónes gtk_hbox_new y gtk_vbox_new, respectivamente. Pronto veremos que estas funciones en acción, en las aplicaciones que crearemos mas tarde. Por ahora, examinemos los parámetros de estas dos funciones: 1. homogeneous : tipo --> gboolean : Obliga a todos los widgets en la caja a ocupar la misma area de acuerdo al widget mas grande en la caja. 2. spacing : tipo --> gint : Determina el espacio entre widgets adyacentes.

7 3. expand : tipo --> gboolean : Permite que la caja empaquetada se expanda para llenar el espacio restante. 4. fill : tipo --> gboolean : Permite que un widget en particular se expanda para ocupar el espacio restante. 5. padding : tipo --> gint : Determina el ancho de un marco que rodea a un widget. 7. Botones. Ahora viene otro componente vital: botones. GTK+ proporciona 4 diferentes tipos de botones: 1. botones simples --> Para realizar una acción al hacer click. 2. botones Toggle --> Con un estado particular activado/desactivado 3. Casillas de verificacion --> Con un estado particular activado/desactivado. 4. botones de selección --> Para marcar solo una opción de entre un grupo de varias. Crear botones de selección es muy similar a las casillas de verificación, y lo que necesitamos hacer extra es especificar un grupo de botones de selección al que pertenece. Los botones de selección son derivados de los botones de verificación, los cuales son derivados de los botones toggle, lo cual significa que tenemos el mismo conjunto de funciones para leer y modificar su estado y también usan los mismos eventos. nota: Para mas información sobre funciones especificas, consulta GTK+ Reference Documentation disponible en: 8. Widgets de entrada. Para crear widgets de texto de una sola línea, que son comúnmente llamados "widgets de entrada", utilizamos una función llamada gtk_entry_new(). Los widgets de entrada son principalmente usados para introducir pequeñas cantidades de información. Miremos ahora un programa que crea una "ventana de acceso", y despliega el campo password, la señal activa ocurre, cuando el botón ha sido pulsado. Teclea lo siguiente y ejecuta el programa como ha sido explicado. /* Creating a Login GNOME-style using GTK+ Toolkit: Created By: Subhasísh Ghosh Date: Wednesday, August 8, 2001 */ #include <gnome.h> static void enter_pressed(gtkwidget *button, gpointer data) GtkWidget *text_entry = data; char *string = gtk_entry_get_text(gtk_entry(text_entry)); g_print(string);

8 int main(int argc, char *argv[]) GtkWidget *app; GtkWidget *text_entry; GtkWidget *label; GtkWidget *hbox; gchar *text; gnome_init("example", "0.1", argc, argv); app = gnome_app_new("example", "entry widget"); gtk_container_border_width(gtk_container(app), 5); hbox = gtk_hbox_new(false, 0); /* we now create a Label: */ label = gtk_label_new("password: "); gtk_misc_set_alignment(gtk_misc(label), 0, 1.0); gtk_box_pack_start(gtk_box(hbox), label, FALSE, FALSE, 0); text_entry = gtk_entry_new(); gtk_entry_set_visibility(gtk_entry(text_entry), FALSE); gtk_box_pack_start(gtk_box(hbox), text_entry, FALSE, FALSE, 0); gtk_signal_connect(gtk_object(app), "delete_event", GTK_SIGNAL_FUNC(gtk_main_quit), NULL); gtk_signal_connect(gtk_object(text_entry), "activate", GTK_SIGNAL_FUNC(enter_pressed), text_entry); gnome_app_set_contents(gnome_app(app), hbox); gtk_widget_show_all(app); gtk_main( ); return 0; Cuando este programa es ejecutado, una ventana de acceso debe de aparecer en la pantalla. Teclea cualquier texto (asumiendo que es un password), presiona enter y observa que es los que sucede. 9. Lista y combos. Las listas y combos juegan el mismo papel que desempeñan en la plataforma Microsoft. Los widgets lista agrupan una lista de cadenas de caracteres que permiten a los usuarios seleccionar una o mas entradas; involucrados en esto, los widgets son así configurados. Las listas son widgets de entrada con un menú emergente agregado que permite a los usuarios seleccionar las opciones disponibles. 10. menús y barras de herramientas. Los varios widgets con los que nos hemos encontrado hasta ahora, son simples widgets que no proveen alguna funcionalidad extraordinaria. Ahora veremos algunas librerías

9 especificas de programación GNOME que ofrecen widgets mas complicados con una rica funcionalidad.. Solo espera un segundo, alguien puede preguntar: "Hey, lo estábamos haciendo bastante bien con código ordinario y todas esas cosas con las que tratamos anteriormente. Cual es el uso de eso llamado "librerías especificas de programación GNOME"?, son de verdad útiles? o estas solo incluyéndolas aquí para hacer tu artículo mas grande?" Bien, esta es la razón para considerar las librerías específicas de programación GNOME. Con código plano de GTK+, aunque aproximadamente todo puede ser hecho, y lo cual usualmente se haría usando las librerías especificas de programación GNOME, pero usando simple y plano código GTK+, a menudo conduce a mucho más código, repetición y bloques ineficientes entre otras cosas, haciendo que toda la programación se infle. Ahora, para prevenir que esto suceda, usamos las librerías especificas de programación GNOME que proveen una gran cantidad de funcionalidades extras y un mucho menor costo de programación. Así, hablemos entonces de "menús" y "Barras de herramientas". GNOME nos permite crear menús y barras de herramientas para nuestros widgets GnomeApp que pueden ser conectados y desconectados de la ventana. En primer lugar tu llenas arreglos con la información necesaria, entonces llamas a nome_app_create_menús o gnome_app_create_toolbar. Los menús y barras de herramientas tienen cada uno sus propiedades definidas en arreglos. Algunas de estas propiedades incluyen tipo, string, callback ponter, etc. La mayor parte del tiempo las entradas a los menús son bastante simples, y podemos usar una o un conjunto de macros suministradas por GNOME que creara la estructura por nosotros; Revisemos algunas de las macros mas utilizadas. NOTA: estas macros son las que crean menús de nivel superior cuando un arreglo es transmitido conteniendo algunas o todas las siguientes estructuras GnomeUIInfo. menú File Edit View Settings Macro GNOMEUIINFO_menú_FILE_TREE(tree) GNOMEUIINFO_menú_EDIT_TREE(tree) GNOMEUIINFO_menú_VIEW_TREE(tree) GNOMEUIINFO_menú_SETTINGS_TREE(tree) Windows GNOMEUIINFO_menú_WINDOWS_TREE(tree) Help Game GNOMEUIINFO_menú_HELP_TREE(tree) GNOMEUIINFO_menú_GAME_TREE(tree) Dentro de los menús de nivel superior existen más de treinta macros para crear menús comunes. Las macros asocian pequeñas imágenes (pixmaps) y combinaciones de teclas

10 para cada opción del menú. Una función Callback es requerida para ser llamada cuando la opción es seleccionada y un apuntador de datos es pasado a la función. Miremos algunas de estas opciones comunes y sus respectivas macros. File -->> New --> GNOMEUIINFO_menú_NEW_ITEM (label, hint, cb, data) Open --> GNOMEUIINFO_menú_OPEN_ITEM (cb, data) Save --> GNOMEUIINFO_menú_SAVE_ITEM (cb, data) Print --> GNOMEUIINFO_menú_PRINT_ITEM (cb, data) Exit --> GNOMEUIINFO_menú_EXIT_ITEM (cb, data) Edit -->> Cut --> GNOMEUIINFO_menú_CUT_ITEM (cb, data) Copy --> GNOMEUIINFO_menú_COPY_ITEM (cb, data) Paste --> GNOMEUIINFO_menú_PASTE_ITEM (cb, data) Settings -->> Preferences --> GNOMEUIINFO_menú_PREFERENCES_ITEM (cb, data) Help -->> About --> GNOMEUIINFO_menú_ABOUT_ITEM (cb, data) Al igual que los menús, las barras de herramientas requieren de un arreglo usando la macro GNOMEUIINFO_ITEM_STOCK (label, tooltip, callback, stock_id). Aquí, "stock_id" es le identificador de un icono predefinido utilizado para esta opción. Veamos este sencillo ejemplo, y observa como trabajan los arreglos y macros en realidad. #include <gnome.h> static void callback (GtkWidget *button, gpointer data) g_print("item Selected"); GnomeUIInfo file_menú[ ] = GNOMEUIINFO_ITEM_NONE ("A menú item", "This is the Status bar info", callback), GNOMEUIINFO_menú_EXIT_ITEM (gtk_main_quit, NULL), GNOMEUIINFO_END ; GnomeUIInfo menúbar[ ] = GNOMEUIINFO_menú_FILE_TREE (file_menú), GNOMEUIINFO_END ;

11 GnomeUIInfo toolbar[ ] = GNOMEUIINFO_ITEM_STOCK ("Print", "This is another tooltip", callback, GNOME_STOCK_PIXMAP_PRINT), GNOMEUIINFO_ ITEM_STOCK ("Exit", "Exit the application", gtk_main_quit, GNOME_STOCK_PIXMAP_EXIT), GNOMEUIINFO_END ; int main (int argc, char *argv[ ]) GtkWidget *app; gnome_init ("example", "0.1", argc, argv); app = gnome_app_new ("example", "A Sample Toolbar and menú"); gnome_app_create_menús (GNOME_APP (app), menúbar); gnome_app_create_toolbar (GNOME_APP (app), toolbar); gtk_widget_show_all (app); gtk_main(); return 0; Este programa crea una pequeña ventana con un menú empotrado y una barra de herramientas. Puedes hacerle click, fijarlo, liberarlo y arrastrarlo por la pantalla. 11. Cajas de diálogo. Ahora veamos el widget que despliega información textual a el usuario en el ambiente GNOME. Si, nos estamos refiriendo a la caja de diálogo. Cuando necesitamos crear cajas de diálogo, llamamos a la función gnome_message_box_new y le pasamos el mensaje, también le indicamos el tipo de caja de diálogo que necesitamos, y los botones que queremos sobre ella. Todo esto es indicado en una lista terminada en NULL. Entonces ligamos el "click" de la señal del widget de diálogo que hemos creado para manejar la función que es transmitida a el botón que el usuario ha pulsado como un entero. Finalmente, llamamos a la función gtk_widget_show para desplegar una caja no modal. Veamos este extracto de código de un programa, el cual crea una simple caja de diálogo, agrega tres botones y responde a el código del usuario.. static void messagebox_clicked(gnomedialog *dlg, gint button, gpointer data) switch (button)

12 case 1: /* user pressed apply */ return; case 0: /* user pressed ok */ case 2: /* user pressed close */ gnome_dialog_close(dlg); GtkWidget *dlg; dlg = gnome_message_box_new("hi, pal, how are you doing??? I am fine!", GNOME_MESSAGE_BOX_QUESTION, GNOME_STOCK_BUTTON_OK, GNOME_STOCK_BUTTON_APPLY, GNOME_STOCK_BUTTON_CLOSE, NULL); gtk_signal_connect (GTK_OBJECT(dlg), "clicked", GTK_SIGNAL_FUNC(messagebox_clicked), NULL); gtk_widget_show (dlg); 12. Conclusiones y enlaces para estudio posterior. Esto resume nuestro viaje en el excitante mundo de la programación GNOME usando el conjunto de herramientas GTK+. NOTA: la programación GNOME no es en absoluto difícil. Una vez que tienes un poco de conocimiento, es realmente sencilla de comprender. Aun hay mucho más por aprender después de este artículo, pero terminado diligentemente, puede ser definitivamente dominado. Para más información y cobertura detallada de este tópico, revisa las siguientes direcciones:

13 Subhasísh Ghosh Tengo 20 años, actualmente estudiante de ingeniería en sistemas computacionales en la India, soy profesional certificado Microsoft (MCP), MSCD, MCP certificado en NT 4.0 recientemente complete la certificación en ingeniería red hat linux (RHCE). He estado trabajando con Linux por mucho tiempo, he programado usando C, C++, VC++, VB, COM, DCOM, MFC, ATL 3.0, Perl, Python y programación Linux usando GTK+. Actualmente aprendiendo la arquitectura del kernel Linux a detalle y haciendo programación Linux kernel.