Por Pablo Machón

Si habéis seguido el cursillo de C de Commodore World, os preguntaréis cómo se puede hacer todo "eso" que estamos acostumbrados a ver en el Amiga: ventanas, gráficos, sonido y demás. Algo más tiene que haber aparte de la programación pura, algo que nos permita conseguir rápidamente el manejo de menús, iconos, ventanas, y todo aquello que se nos ocurra, dentro del entorno gráfico multitarea.

En el interior del Amiga

Creo que está claro: la máquina ha de llevar incorporadas unas funciones que le permitan manejar todo esto. De lo contrario, cada programador se inventaría su sistema Intuition, sus ventanas, sus iconos... resultando en un caos total. Estas rutinas tan prácticas y necesarias son las llamadas librerías (más bien deberían llamarse "bibliotecas", pero es más fácil... ejem.!).

Conviene señalar que las librerías existen de varias formas: residen en ROM, en la memoria, o son cargadas de disco cuando se las necesita.

Uno de los aspectos más prácticos de la librerías es que pueden ser utilizadas por muchos programas al mismo tiempo, lo que aporta grandes ventajas. Se ahorra mucha memoria, al reducir el código a la mitad (puesto que es común): se generalizan los sistemas utilizados, haciéndose los programas más parecidos en su manejo unos a otros, y facilitando su uso; y se ahorra también espacio en el disco, puesto que los programas son más cortos.

Como hemos dicho, las librerías son simples rutinas (bueno, no tan simples), que hacen casi todo el trabajo. Para usarlas sólo hay que abrirlas y "llamar" a la parte de la librería que te interesa, es decir, a la rutina que quieres.

Por ejemplo, supongamos que quieres abrir la librería "Intuition". Todo lo que hay que hacer es utilizar la función OpenLibrary() para conseguirlo. ¿Fácil? No tanto. Utilizar esta función requiere alguna cosilla más.

El "lenguaje" de las librerías

Primero, debes incluir algunos ficheros en tu programa, para que el compilador entienda de qué hablas. Por un lado, le estás diciendo que maneje librerías, así, sin más. El encargado de hacer esto en EXECm una parte de la ROM que controla la multitarea, librerías, y otras cosillas. De momento teclea al principio de tu programa:

     #include "exec/types.h"

La razón por la que hay que hacer esto es sencilla; el compilador entiende C, no entiende "AMIGA-ROM". Hay que indicarle, de alguna manera, qué palabras, constantes, funciones, etc, se van a utilizar.

Por esta misma razón, se debe incluir el fichero que contiene las definiciones de constantes y otras cosas referentes a intuition:

     #include "intuition/intuition.h"

Bueno, ya estamos listos para comenzar. Ahora, abramos la librería. Para ello, inicializaremos un puntero con la función OpenLibrary(). Primero declaramos lo que vamos a usar:

     struct IntuitionBase *IntuitionBase;

Es el puntero citado. Ahora, por fin, dentro de main(), abrimos:

     IntuitionBase = (struct IntuitionBase *);
     OpenLibrary("intuition.library",0);

Ya lo tenemos. Antes de seguir, unas aclaraciones; el aspecto de las mayúsculas y las minúsculas en C es fundamental. IntuitionBase se escribe así, junto y con la "I" y la "B" en mayúsculas, y no de otro modo. Y esto también vale para las funciones: OpenLibrary, etc. El número detrás de la "intuition.library" indica la versión; en este caso 0 es el comodín. Además, esta forma de abrir librerías es general; el resto se abren igual, inicializando su propio puntero.

Ahora que hemos abierto la librería... ¡Alto! Todavía no estamos seguros. Vamos a comprobarlo...

     If(IntuitionBase == NULL)exit(FALSE)

Así comprobamos si realmente se abrió. Si no, el programa finaliza inmediatamente. Ahora podemos pasar a utilizar las rutinas que nos proporciona esta librería. Por ejemplo, abramos una ventana dentro de una pantalla nueva. Para ello, y como en casi todas las demás funciones del AMIGA, tenemos que inicializar unas estructuras de datos (que informen de lo que queremos), y luego llamar a la rutina correspondiente. Así de sencillo. Toda la complicación viene a la hora de decidir qué es lo que se quiere hacer (hay tantas cosas...).

Abriremos primero la pantalla, y luego, dentro de ella, la ventana. Por lo tanto, lo primero que hay que hacer es inicializara la estructura de la pantalla. Lo haremos fuera de main(), puesto que es más fácil. El listado 1 lo muestra con comentarios.

Como vemos, ya de entrada tenemos bastantes posibilidades, de las que hemos aprovechado sólo unas pocas. Ahora que ya hemos definido cómo será nuestra pantalla, simplemente la creamos, o mejor dicho, la abrimos:

     struct Screen *s;
     s = OpenScreen(&MiPantalla);
     if (s == 0) exit(FALSE);

Es muy importante comprender cómo funciona esto. Primero hemos inicializado la estructura MiPantalla, que contiene datos relativos a la pantalla que crearemos. Después, al abrir la pantalla, inicializamos otra estructura s con los datos de MiPantalla; se trata por un lado de una estructura inicial que sirve sólo para "rellenar" las estructuras de las nuevas pantallas, pero que tras la inicialización queda intacta para la siguiente pantalla, y así sucesivamente. Con esto ya tenemos la pantalla abierta. La ventana se abre de forma casi idéntica: primero la definimos (listado 2), y luego hacemos una llamada a OpenWindow

     struct Window *w;
     w=OpenWindow(&MiVentana);
     If (w==0) exit(FALSE);

De nuevo hemos utilizado la estructura "madre" MiVentana para crear otra ventana. Para ver esto más claramente, el listado 4 muestra cómo abrir una pantalla, y dos ventanas, una en la pantalla del WorkBench y otra en la recién creada.

Para cerrar tanto la ventana como la pantalla, deben utilizarse CloseWindow() y CloseScreen(), que tienen por argumentos la ventana y la pantalla.

     CloseWindow(w);
     CloseScreen(s);

En este caso s y w son los punteros a la pantalla y ventana. No podemos utilizar MiVentana ni MiPantalla, ya que éstos son punteros a estructuras que NO pertenecen realmente a ninguna ventana o pantalla.

De este modo tenemos las bases para iniciar cualquier programa que utilice el sistema intuition.

Utilizando los diferentes flags que nos permiten las estructuras antes comentadas, podemos crear pantallas de cualquier resolución, colores, etc.

Este pequeño ejemplo de utilización de librerías es sólo una introducción a lo que es la programación "a fondo" del Amiga. Dentro de Intuition hay funciones para manejar Gadgets (en sus múltiples variantes), Menús, Alertas, etc. Otras librerías interesantes son la "Graphics.library", que posee funciones para dibujar gráficos, manejar texto con diferentes Fonts, utilizar patrones para el rellenado, manejo de brushes, etc.; "Layers.library", que maneja "capas" de pantalla, para permitir las superposiciones y scrolls. Otras librerías son por ejemplo las que se refieren a rutinas matemáticas, fuentes de caracteres, etc. En general, casi todo lo que se puede hacer con Amiga es accedido por medio de las librerías.

Es conveniente indicar que estas librerías se apoyan unas en otras, por ejemplo Intuition está claro que se vale de Graphics y de Layers, entre otras, para manejar ventanas y pantalla. De este modo, uno puede profundizar lo que desee, dominando el aparato en proporción al grado de incursión que se practique.

Es absolutamente imposible documentar el contenido de las librerías en este artículo. En otra ocasión nos dedicaremos a las librerías en concreto, una vez que se haya comprendido el significado de las librerías. De momento en el cuadro podrás encontrar la bibliografía disponible al efecto, aunque la mayoría está en inglés.

Espero que esto os haya aclarado algo; por lo menos para que los próximos artículos sean más comprensibles. Mas adelante trataremos de explorar las funciones de Intuition a fondo.

struct NewScreen MiPantalla =     /* Esta es la estructura de datos de la pantalla */
  {
  0,                              /* Esquina superior izquierda x=0*/
  0,                              /* y=0 */
  320,                            /* Anchura */
  200,                            /* Longitud */
  2,                              /* Profundidad (num. de colores); es el exponente de una potencia de 2. En
                                     este caso, 2^2=4 colores */
  0,1,                            /* DetailPen y BlockPen. Controlan los colores de detalle y bloque */
  NULL,                           /* Modos especiales: HIRES (alta resoluci�n), INTERLACE (entrelazado), SPRITES
                                     (si los usamos) y HAM (4096 colores) */
  CUSTOMSCREEN,                   /* Tipo de pantalla */
  NULL,                           /* Fuente de caracteres, por defecto TOPAZ */
  "Pantalla de Prueba",           /* T�tulo */
  NULL,                           /* Gadgets de la pantalla */
  NULL,                           /*Especificar CUSTOMBITMAP si queremos usar nuestro propio bit map */
  };

struct NewWindow MiVentana =     /* Ahora la estructura de la ventana */
  {
  30,30,                         /* Esquina superior izquierda x e y*/
  100,150,                       /* Ancho y largo */
   0,                            /* Detailpen y Blockpen */
   1,
  NULL,                          /* Banderas IDCMP para detecci�n de acontecimientos */
  SMART_REFRESH | ACTIVATE | WINDOWSIZING | WINDOWDRAG | WINDOWDEPTH,
                                 /* Banderas de la ventana */
  NULL,                          /* Puntero al primer, Gadget */
  NULL,                          /* Puntero a Checkmark */
  "Ventana de prueba",           /* T�tulo */
  NULL,                          /* Puntero a pantalla */
  NULL,                          /* Puntero a bitmap */
  10,10,                         /* Ancho y alto m�nimos */
  640,200,                       /* y m�ximos */
  WBENCHSCREEN                   /* Tipo de pantalla*/
  };

#include "exec/types.h"                /* Incluimos EXEC*/
#include "intuition/intuition.h"       /* y tambi�n Intuition*/
struct IntuitionBase *IntuitionBase;   /* puntero necesario para manejar la librer�a*/
struct NewScreen MiPantalla =          /* Esta es la estructura de datos de la pantalla*/
  {
  0,                                   /* Esquina superior izquierda x=0*/
  0,                                   /* y=0 */
  320,                                 /* Anchura */
  200,                                 /* Longitud */
  2,                                   /* Profundidad (num. de colores); es el exponente de una potencia de 2, en
                                          este caso 2^2=4 colores */
  0,1,                                 /* DetailPen y BlockPen. Controlan los colores de detalle y bloque */
  NULL,                                /* MOdos especiales: HIRES (alta resoluci�n), INTERLACE (entrelazado),
                                          SPRITES (si los usamos) y HAM (4096 colores) */
  CUSTOMSCREEN,                        /* Tipo de pantalla */
  NULL,                                /* Fuente de caracteres, por defecto TOPAZ */
  "Pantalla de Prueba",                /* T�tulo */
  NULL,                                /* Gadgets de la pantalla */
  NULL,                                /* Especificar CUSTOMBITMAP si queremos usar nuestro propio bit map */
  };
struct NewWindow MiVentana =           /* Ahora la estructura de la ventana */
  {
  30,30,                               /* Esquina sup izquierda:x e y*/
  100,150,                             /* Ancho y largo */
   0,                                  /* Detailpen y Blockpen */
   1,
  NULL,                                /* Banderas IDCMP para detecci�n de acontecimientos */
SMART_REFRESH | ACTIVATE |WINDOWSIZING |WINDOWDRAG | WINDOWDEPTH,
                                       /* Banderas de la ventana */
 NULL,                                 /* Puntero al primer Gadget */
 NULL,                                 /* Puntero a Checkmark */
 "Ventana de prueba",                  /* T�tulo */
 NULL,                                 /* Puntero a pantalla */
 NULL,                                 /* Puntero a bitmap */
 10,10,                                /* ancho y alto minimos */
 640,200,                              /* y m�ximos */

  WBENCHSCREEN              /* Tipo de pantalla*/
  };
main()                      /* El programa en si */
  {
  struct Screen *s;         /* Declaramos las estructuras*/
  struct Window *w;
  struct Window *w2;
  long int k;
  IntuitionBase = (struct IntuitionBase *)
OpenLibrary("intuition.library",0);         /* Abrimos la librer�a */
  if(IntuitionBase == NULL) exit(FALSE);    /* Chequeo por si acaso...*/
  s = OpenScreen(&MiPantalla;);              /* Abro la pantalla s con los par�metros de MiPantalla */
  if(s == 0) exit (FALSE);                  /* Ojo..*/
  w = OpenWindow(&MiVentana;);               /* Abro la Ventana w con los par�metros de MiVentana, es decir, en el
                                               Workbenchm etc*/
  if(w == 0)                                /* Comprobando*/
        exit (FALSE);
  MiVentana.Screen = s;                     /* MODIFICO ciertos par�metros de MiVentana; la pantalla ser� s, en
                                               lugar de NULL (WBench)*/
  MiVentana.Type = CUSTOMSCREEN;            /* Tambi�n modifico el tipo de pantalla, que antes era WBENCHSCREEN */
  w2 = OpenWindow(&MiVentana;);              /* Finalmente abro w2 con los par�metros reci�n modificados de
                                               MiVentana*/
  if(w2 == 0)
        exit (FALSE);                       /* Y compruebo*/
  for (k=0;k<1000000;k++);                  /* Bucle de retardo*/
  CloseWindow(w);                           /* Cerramos todo*/
  CloseScreen(s);
  CloseLibrary(IntuitionBase);              /* La librer�a tambi�n*/
  Exit(TRUE);                               /* Salida*/
  }