El canvas de GNOME

Tabla de contenidos

Bases
Objetos por defecto
Ejemplo sobre los objetos
Trabajar con los objetos
Crear objetos propios
Un objeto propio

El canvas de GNOME es un widget que ofrece un método fácil y potente para presentar los datos de una aplicación. Este objeto es una simple área en blanco, donde se pueden insertar objectos GnomeCanvasItem, los cuales representan los elementos mostrados en el GnomeCanvas. De este modo es posible trabajar con gráfico en términos de objetos.

Bases

Modos del GnomeCanvas

El GnomeCanvas puede trabajar en dos modos: el modo RGB y el modo GDK. En el modo RGB, los objetos en el GnomeCanvas dibujan su contenido en un búfer RGB, y una vez que todos están actualizados, el búfer se muestra en el widget. En el modo GDK, los objetos dibujan directamente sobre un GdkPixmap usando las primitivas de dibujo de GDK.

El modo RGB también se llama antialiased, ya que todos los objetos estándares que vienen en GnomeCanvas usan la librería libart_lgpl, que tiene funciones para dibujar figuras con anti-aliasing.

Figura 1. Modo RGB

Modo RGB

Figura 2. Modo GDK

Modo GDK

Grupos

Los grupos se crean con el objecto GnomeCanvasGroup. Todos los objetos que están dentro de un grupo funcionan como una unidad. Por ejemplo, si un grupo es destruido, todos los objetos contenidos en él también serán destruidos.

Siempre hay un grupo principal, en el cual se sitúan todos los objetos del canvas. Este grupo se puede obtener usando la función gnome_canvas_root.

Crear un canvas

Para crear el widget se usan las funciones gnome_canvas_new (modo GDK) o gnome_canvas_new_aa (modo RGB).

GtkWidget* gnome_canvas_new ();
void;

GtkWidget* gnome_canvas_new_aa ();
void;

Cuando se crea el widget, se crea un grupo, conocido como Root, en el cual se insertarán todos los objetos GnomeCanvasItem. Para crear nuevos elementos es necesario conocer ese grupo, que se puede obtener con gnome_canvas_root.

Todos los objetos que se crean en el canvas deben pertenecer al grupo devuelto por gnome_canvas_root, o a alguno de sus grupos hijos. Los objetos se introducen en los grupos con gnome_canvas_item_new.

GnomeCanvasGroup * gnome_canvas_root (canvas); 
GnomeCanvas * canvas;
GnomeCanvasItem * gnome_canvas_item_new (parent,  
 type,  
 first_arg_name,  
 ); 
GnomeCanvasGroup * parent;
GtkType * type;
const gchar * first_arg_name;
 ;

En este sencillo ejemplo se ve cómo crear un círculo en el canvas.

Ejemplo 1. Canvas Básico


#include <gnome.h>

int
main(int argc, char** argv)
{
        GtkWidget *window;
        GtkWidget *canvas;
        GnomeCanvasGroup *root;

        /* inicializamos las librer&iacute;as */
        gnome_init("basic-canvas", "0.1", argc, argv);

        /* crear una ventana que contenga al canvas */
        window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
        g_signal_connect(G_OBJECT(window), "destroy", gtk_main_quit, 0);

        /* canvas en modo RGB */
        canvas = gnome_canvas_new_aa();
        gtk_container_add(GTK_CONTAINER(window), canvas);

        root = gnome_canvas_root(GNOME_CANVAS(canvas));

        /* poner un c&iacute;rculo, con fondo verde y borde azul */
        gnome_canvas_item_new(root,
                        gnome_canvas_ellipse_get_type(),
                        "x1", 0.0,
                        "y1", 0.0,
                        "x2", 100.0,
                        "y2", 100.0,
                        "fill_color_rgba", 0x00ff00ff,
                        "outline_color_rgba", 0x0000ffff,
                        "width_units", 3.0,
                        NULL);

        /* mostrar los widgets creados y entrar en el bucle gtk_main */
        gtk_widget_show_all(window);
        gtk_main();
}

  

Del ejemplo, lo más significativo es la llamada a gnome_canvas_item_new, a la cual se pasan los valores que tendrá el círculos dibujado en el canvas.

Zoom

Una de las principales ventajas de GnomeCanvas es la posibilidad de hacer zoom.

Para alterar el zoom del canvas se usa la función gnome_canvas_set_pixels_per_unit. Cuando cambiamos el zoom, los objetos se actualizan para adoptar la nueva escala.

void gnome_canvas_set_pixels_per_unit(canvas,  
 n); 
GnomeCanvas*  canvas;
double  n;

Ejemplo 2. Cambiar el zoom

      /* Poner un zoom del 200 % */
      gnome_canvas_set_pixels_per_unit(canvas, 2.0);

      /* Poner un zoom del 50 % */
      gnome_canvas_set_pixels_per_unit(canvas, 0.5);
  

Región del canvas

El canvas tiene una región conceptualmente infinita, sólo limitada por el rango de double. Sin embargo, la mayoría de las veces sólo interesa trabajar sobre un área concreta, e incluso disponer de barras de desplazamiento para recorrerla.

Para poner una región en el canvas se usa gnome_canvas_set_scroll_region. Esta función define un rectángulo que nos servirá, por ejemplo, para definir los valores de las barras de desplazamiento del canvas.

void gnome_canvas_set_scroll_region(canvas,  
 x1,  
 y1,  
 x2,  
 y2); 
GnomeCanvas*  canvas;
double  x1;
double  y1;
double  x2;
double  y2;

La forma más sencilla de usar barras de desplazamiento para el canvas es añadirlo a un GtkScrolledWindow.

Ejemplo 3. GnomeCanvas y GtkScrolledWindow

GtkWindow *scrolled;
GtkWindow *canvas;

/* GtkScrolledWindow para el canvas */
scrolled = gtk_scrolled_window_new(NULL, NULL);

/* canvas en modo RGB */
canvas = gnome_canvas_new_aa();
gtk_container_add(GTK_CONTAINER(scrolled), canvas);
gnome_canvas_set_scroll_region(GNOME_CANVAS(canvas), x1, x2, y1, y2);
  

Para desplazar las barras a una posición determinada se puede usar gnome_canvas_scroll_to

void gnome_canvas_scroll_to(canvas,  
 cx,  
 cy); 
GnomeCanvas*  canvas;
int  cx;
int  cy;