Visor de imágenes

Crear un proyecto en Anjuta

Antes de empezar a programar, deberá configurar un proyecto nuevo en Anjuta. Esto creará todos los archivos que necesite para construir y ejecutar el código más adelante. También es útil para mantener todo ordenado.

Inicie Anjuta y pulse ArchivoNuevoProyecto para abrir el asistente de proyectos.

Elija GTKmm (simple) de la pestaña C++, pulse Adelante y rellene los detalles en las siguientes páginas. Use visor-imagenes como nombre de proyecto y de carpeta.

Asegúrese de que Usar GtkBuilder para la interfaz del usuario está desactivado, ya que, en este tutorial, la IU se creará manualmente. Revise el tutorial del afinador de guitarra si quiere aprender a usar el constructor de interfaces.

Pulse Aplicar y se creará el proyecto. Abra src/main.cc desde las pestañas Proyecto o Archivo. Debería ver algo de código que comience con las líneas:


#include <gtkmm.h>
#include <iostream>

#include "config.h">

Construir el código por primera vez

Esto es una configuración de código C++ usando GTKmm. Se ofrecen más detalles a continuación; omita esta lista si entiende los conceptos básicos:

Las tres líneas #include en la parte superior incluyen las bibliotecas config (definiciones útiles para construcción con autoconf), gtkmm (interfaz de usuario) iostream (C++-STL). Las funciones de estas bibliotecas se usan en el resto del código.

La función main crea una ventana (vacía) nueva y establece el título de la ventana.

La llamada kit::run() inicia el bucle principal de GTKmm, que ejecuta la interfaz de usuario y empieza a escuchar eventos (como pulsaciones del ratón y del teclado). Como se ha pasado la ventana como argumento a esta función, la aplicación se cerrará automáticamente cuando se cierre la ventana.

Este código está listo para usarse, por lo que puede compilarlo pulsando ConstruirConstruir proyecto (o pulsando MayúsF7).

Pulse Ejecutar en la siguiente ventana que aparece para configurar una construcción de depuración. Esto sólo necesita hacer una vez para la primera construcción.

Crear la interfaz de usuario

Ahora se dará vida a la ventana vacía. GTKmm organiza la interfaz de usuario con varios Gtk::Container que pueden contener otros widgets e incluso otros contenedores. Aquí se usará el contenedor más sencillo disponible, una Gtk::Box:


int
main (int argc, char *argv[])
{
	Gtk::Main kit(argc, argv);

	Gtk::Window main_win;
	main_win.set_title ("image-viewer-cpp");

	Gtk::Box* box = Gtk::manage(new Gtk::Box());
	box->set_orientation (Gtk::ORIENTATION_VERTICAL);
	box->set_spacing(6);
	main_win.add(*box);

	image = Gtk::manage(new Gtk::Image());
	box->pack_start (*image, true, true);

	Gtk::Button* button = Gtk::manage(new Gtk::Button("Open Image…"));
	button->signal_clicked().connect (
		sigc::ptr_fun(&on_open_image));
	box->pack_start (*button, false, false);

	main_win.show_all_children();
	kit.run(main_win);

	return 0;
}

La primera línea crea los widgets que se quieren usar: un botón para abrir una imagen, el widget del visor de imágenes en sí y la caja que se usará como contenedor.

Las llamadas a pack_start añaden los dos widgets a la caja y definen su comportamiento. La imagen se expandirá en cualquier espacio disponible, mientras que el botón será tan grande como se necesite. Se dará cuenta de que no se establecen tamaños explícitos de los widgets. Generalmente, en GTKmm no se necesita ya que hace que sea mucho más sencillo tener una distribución que se ve bien con diferentes tamaños de la ventana. A continuación, se añade la caja a la ventana.

Se debe definir qué sucede cuando el usuario pulsa el botón. GTKmm usa el concepto de señales. Cuando se pulsa el botón, emite la señal clicked, que se puede conectar a alguna acción. Esto se ha hecho usando el método signal_clicked().connect, que indica a GTKmm que llame a la función on_open_image cuando se pulsa el botón y que pase la imagen como un argumento adicional a la función. El retorno de la llamada se definirá en la siguiente sección.

El último paso es mostrar todos los widgets en la ventana usando show_all_children(). Esto es equivalente a usar el método show() en cada uno de los widgets.

Mostrar la imagen

Ahora se definirá el manejador de la señal clicked para el botón mencionado anteriormente. Añada este código antes del método main.


Gtk::Image* image = 0;

static void
on_open_image ()
{
	Gtk::FileChooserDialog dialog("Open image",
	                              Gtk::FILE_CHOOSER_ACTION_OPEN);
	dialog.add_button (Gtk::Stock::OPEN,
	                   Gtk::RESPONSE_ACCEPT);
	dialog.add_button (Gtk::Stock::CANCEL,
	                   Gtk::RESPONSE_CANCEL);

	Glib::RefPtr<Gtk::FileFilter> filter =
		Gtk::FileFilter::create();
	filter->add_pixbuf_formats();
	filter->set_name("Images");
	dialog.add_filter (filter);

	const int response = dialog.run();
	dialog.hide();

	switch (response)
	{
		case Gtk::RESPONSE_ACCEPT:
			image->set(dialog.get_filename());
			break;
		default:
			break;
	}
}

Esto es un poco más complicado que todo lo que se ha intentado hasta ahora, así que se puede desglosar:

El diálogo para elegir el archivo se crea usando el constructor de Gtk::FileChooserDialog. La función toma el título y el tipo del diálogo. En este caso, es un diálogo de tipo Open.

Las siguientes dos líneas añaden un botón Abrir y Cerrar en el diálogo.

Note que se está usando nombres de botones del almacén de GTK, en lugar de escribir manualmente «Cancelar» o «Abrir». La ventaja de usar nombres del almacén es que las etiquetas de los botones ya estarán traducidas en el idioma del usuario.

El segundo argumento del método add_button() es un valor para identificar el botón pulsado. Aquí también se usan valores predefinidos proporcionados por GTKmm.

Las dos líneas siguientes restringen el diálogo Abrir para que sólo muestre archivos que se puedan abrir con Gtk::Image. Primero se crea un objeto de filtro; luego se añaden los tipos de archivos soportados por el Gdk::Pixbuf (que incluye la mayoría de los formatos de imagen como PNG y JPEG) al filtro. Por último, se establece que este filtro sea el filtro del diálogo Abrir.

Glib::RefPtr es un puntero inteligente usado aquí que se asegura de que el filtro se destruye cuando ya no se hace ninguna referencia a él.

dialog.run muestra el diálogo Abrir. El diálogo esperará a que el usuario seleccione una imagen; cuando lo haga, dialog.run devolverá el valor Gtk::RESPONSE_ACCEPT (devolvería Gtk::RESPONSE_CANCEL si el usuario pulsara Cancel). La sentencia switch comprueba esto.

Se oculta el diálogo Abrir porque ya no se necesita más. El diálogo se ocultará de todos modos, ya que sólo es una variable local, y se destruye (y por lo tanto se oculta) cuando el ámbito termina.

Asumiendo que el usuario pulsó Abrir, la siguiente línea carga el archivo en la Gtk::Image, por lo que se muestra.

Construir y ejecutar la aplicación

Todo el código debería estar listo para ejecutarse. Pulse ConstruirConstruir proyecto para construir todo otra vez y pulse EjecutarEjecutar para iniciar la aplicación.

Si todavía no lo ha hecho, elija la aplicación Debug/src/visor-imagenes en el diálogo que aparece. Finalmente, pulse Ejecutar y disfrute.

Implementación de referencia

Si tiene problemas con este tutorial, compare su código con este código de referencia.

Siguientes pasos

Aquí hay algunas ideas sobre cómo puede extender esta sencilla demostración:

Haga que el usuario selecciona una carpeta en vez de un archivo, y proporcione controles para moverse por todas las imágenes de una carpeta.

Aplicar filtros aleatorios y efectos a la imagen cuando se carga y permitir al usuario guardar la imagen modificada.

GEGL proporciona la capacidad de manipular imágenes de manera potente.

Permitir al usuario cargar imágenes desde recursos de red compartidos, escáneres y otras fuentes más complicadas.

Puede usar GIO para gestionar transferencias de archivos de red y similares, y GNOME Scan para gestionar el escaneado.