COMO ESCRIBIR UN PLUG-IN PARA GIMP (parte I)
Escrito por: David Neary
Traducido de aquí por AntI para Gimp-es
En este articulo, presento las bases de los plug-ins (añadidos) de Gimp y una introducción a la libreria API de Gimp.Tambien presento como usar la PDB, para poner a disposicion de otros autores, nuestros añadidos (plug-ins).
Introducción
Los nuevos desarrolladores, a menudo, están intimidados por el tamaño y la reputación de Gimp. Piensa que escribir un plug-in será una tarea difícil.
La meta de este artículo es derrumbar este sentimiento, mostrando lo fácil que puede ser hacer un plug-in en C. En esta parte, presento los elementos básicos. Veremos como instalar un plug-in, como obtener datos de una imagen y manipularla directamente.
Arquitectura
Arquitectura
El interfaz de código de Gimp está centralizado en la Procedural database (PDB). Al empezar, Gimp busca en los lugares predefinidos scripts y plug-ins, y pregunta a cada nuevo script para identificarlo.
A la vez, el plug-in se manifiesta a la PDB, y pasa informaciones como la posición que desearía tener en el menú jerarquía, parámetros de entrada y salida.
Cuando un script o un plug-in quiere usar nuestro plug-in, se comunica con la PDB, la cual maneja parámetros de comunicación en una dirección y la otra de una manera transparente.
Las funciones internas que desean ser expuestas a plug-ins tienen que ser empaquetadas primero en el corazón, que lo registrará en la PDB, y en segundo lugar, en la libgimp que permitirá a la función ser llamada como uno normal.
Esta fué la introducción - ahora, examinaremos nuestro primer añadido, un "Hello, world!".
Compilando el plug-in
Para ser capaz de compilar plug-ins simples para El Gimp, uno necesita Libgimp headers, tanto como una utilidad asociada llamada gimptool (herramienta de Gimp).
Con esa utilidad, se puede instalar un añadido tanto en un directorio privado (~/.gimp-2.0/plug-ins), como en el directorio global de plug-ins.
La sintaxis es:
gimptool --install plugin.c or gimptool --install-admin plugin.c
Esta utilidad, con otras opciones, puede tambien ser usada para instalar scripts o desinstalar plug-ins.
Comportamiento
Un añadido GIMP puede, tipicamente, comportarse de tres maneras diferentes. Puede tomar datos de la imagen, modificarlos y enviar de vuelta la imagen modificada, como "detección de bordes". Puede generar una imagen y devolverla, como algunos scripts-fu o plug-ins que leen archivos como jpge. O pueden obtener una imagen , y procesarla sin modificar los datos, como un plug-in para guardar archivos.
Esenciales
#include <libgimp/gimp.h>
Este header pone a nuestra disposición todos los elementos básicos de plug-ins.
GimpPlugInInfo PLUG_IN_INFO = {
init,
quit,
query,
run
};
Esta estructura tiene que tener ese nombre. Contiene cuatro punteros a las funciones, que pueden ser llamadas una serie de veces durante la vida del plug-in, "init y quit" son opcionales, y pueden tener valores NULL, pero las últimas dos funciones "query y run" son obligatorias.
La función "init ()" es llamada cada vez que El Gimp arranca. Esta función no se usa, normalmente. Algunos plug-ins la usan para hacer una busqueda secundaria que no hace el corazón. Esta función no la usa ningún plug-in estandar GIMP, pero puede ser útil, por ejemplo, para un plug-in que quiera registrar un procedimiento condicional en algunos archivos presentes.
La función "quit()", tampoco se usa mucho. Es llamada cuando El Gimp esta a punto de cerrarse, para liberar algunos recursos. Se usa en el plug-in script-fu.
La función"query()" es llamada la primera vez que el plug-in es presente, y, entonces cada vez que el plug-in cambia.
La función "run()" es la pieza central de los plug-ins. Es llamado cuando el plug-in es requerido para ejecutarse. Obtiene el nombre del plug-in (como un plug-in puede registrar varios procedimientos), parámetros de entrada, y un puntero a los parámetros de salida, entonces determina si es lanzado de manera interactiva o mediante un script, y realiza todo el procesado del plug-in.El prototipo es:
void run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals);
MAIN ()
MAIN es un macro en C que mantiene un poco de magia oscura al iniciar argumentos. Tambien llama la función apropiada PLUG_IN_INFO dependiendo del tiempo. Tu plug-in lo necesita.
La función"query()"
"query()" trata de registros de procedimientos y definición de argumentos de entrada. Estas informaciones son guardadas para acelerar el tiempo de arranque, y se refresca, solo, cuando el plug-in es modificado.
Para nuestro plug-in "Hello, world!", la función "query" se parecerá a esto:
static void query (void)
{
static GimpParamDef args[] = {
{
GIMP_PDB_INT32,
"run_mode",
"Run mode"
},
{
GIMP_PDB_IMAGE,
"image",
"Input image"
},
{
GIMP_PDB_DRAWABLE,
"drawable",
"Input drawable"
}
};
gimp_install_procedure (
"plug_in_hello",
"Hello, world!",
"Displays \"Hello, world!\" in a dialog",
"David Neary",
"Copyright David Neary",
"2004",
"/Filters/Misc/_Hello world...",
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
}
GimpParamDef contiene tres cosas - tipo de parámetros, su nombre, y una variable que describe el parámetro.
gimp_install_procedure declara el nombre del procedimiento, alguna descripción y variables de ayuda, la ruta del menú donde se situará el plug-in, manejadores del tipo de archivo para el plug-in, y al final, número de parámetros de entrada y salida, asi como los descriptores de parámetros.
"RGB*, GRAY*" declara el tipo de imagen manejado. Puede ser RGB, INDEXED o GRAY, con o sin Alfa. Así que "RGB*, GRAY*" describen los tipos de imágenes RGB, RGBA, GRAY o GRAY.
GIMP_PLUGIN declara este procedimiento como externo, y no puede ser ejecutado en el corazón de El Gimp.
Por añadir una coletilla, corre una función ahora, podemos chequear que nuestro plug-in tiene
todos los elementos esenciales, y prueba que se registre en la PDB con el plug-in "Exts->Visor de complementos".
Detalles de Plug-in
Nuestro plug-in está en el menú
La función run()
La otra función requerida para PLUG_IN_INFO es run. El corazón del plug-in permace allí.
Los valores de salida (return_vals, en el prototipo) deben tener al menos un valor asociado - el estado del plug-in. Normalmente, este parámetro se mantendrá en "GIMP_PDB_SUCCESS".
Run-modes
Se puede ejecutar un plug-in de varias maneras diferentes, se puede ejecutar desde un menú de GIMP si El Gimp se está ejecutando interactivamente, o desde un script o un batch, o desde "Filtros->Repetir último".
Los parámetros de salida de "run_mode" pueden tener uno de estos valores:
"GIMP_RUN_INTERACTIVE", "GIMP_RUN_NONINTERACTIVE" o "GIMP_RUN_WITH_LAST_VALS". "GIMP_RUN_INTERACTIVE" es, normalmente, el único caso donde uno crea un diálogo de opciones. De otra manera, uno llama, directamente, al proceso con los valores de parámetros de entrada o desde la memoria.
Para nuestro plug-in de prueba, simplemente, representaremos un diálogo conteniendo un mensaje "Hello, world!". Afortunadamente, esto es realmente fácil con GTK+. Nuestra función run podría ser:
static void run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpRunMode run_mode;
/* Setting mandatory output values */
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
/* Getting run_mode - we won't display a dialog if
* we are in NONINTERACTIVE mode */
run_mode = param[0].data.d_int32;
if (run_mode != GIMP_RUN_NONINTERACTIVE)
g_message("Hello, world!\n");
}
Ahora, cuando ejecutamos nuestro plug-in, hay acción:
Próxima parte
En la próxima parte avanzaremos, haciendo un plug-in más útil que manejará los datos de la imagen. Veremos como usar la arquitectura de la imagen de El Gimp para hacer que el plug-in funcione mejor, procesando la imagen cuadro a cuadro.
Autor: Dave Neary (Bolsh at NOSPAM.gimp.org) Traducción:AntI (Ant.Ign at gmail)
Este trabajo está licenciado bajo una licencia Creative Commons Attribution-NonCommercial-ShareAlike 2.5.