aseprite/jinete/docs/jinete-es.txt

                       Jinete 0.4

                      A GUI library.

                 By David A. Capello, 2005.



#include <std_disclaimer.h>

   "No me responsabilizo de ning<6E>n efecto, adverso u otro que este c<>digo
    pueda tener sobre usted, su ordenador, su salud, su perro, o cualquier
    otra cosa que pueda imaginar. Uselo bajo su propia responsabilidad."



======================================
============ Introducci<63>n ============
======================================

  Jinete es una librer<65>a que proporciona un Interfaz Gr<47>fico de
  Usuario (GUI por sus siglas en ingl<67>s), sencilla y r<>pida tanto de
  usar, como de programar y dise<73>ar di<64>logos.  Conjuntamente con la
  librer<65>a Allegro, se encarga de controlar los eventos que produce el
  usuario a trav<61>s del rat<61>n (mouse) y el teclado.



===================================
============ Copyright ============
===================================

  Jinete es gift-ware (software-regalo).  Puede usar, modificar,
  redistribuir, y generalmente modificarlo de cualquier forma que
  desee, y no debe darme nada a cambio. Si redistribuye partes de este
  c<>digo o hace una aplicaci<63>n con <20>l, ser<65>a bonito que mencionase
  Jinete en alguna parte de los cr<63>ditos, pero no est<73> obligado a
  hacerlo.



================================================
============ Funcionamiento General ============
================================================

  El GUI se maneja a trav<61>s de widgets (controles u objetos gr<67>ficos).
  Cada widget puede contener varios widgets hijos, donde cada uno de
  <20>stos tiene un puntero a su <20>nico padre; siendo el padre ra<72>z de
  todos los widgets: el manager (gestor) principal del GUI (el cual
  tambi<62>n es un widget).

  Jinete es controlado con el manager principal, el cual es creado por
  primera y <20>nica vez a trav<61>s de la primer llamada de jmanager_new,
  y deber<65> ser eliminado mediante jmanager_free.

  Los managers s<>lo pueden contener ventanas dentro, mientras que las
  ventanas pueden contener todo tipo de widgets, inclusive otros
  managers alternativos (o sub-managers) los cuales a su vez pueden
  contener otras ventanas (con Jinete puede lograr algo as<61> como la
  MDI de Windows).

  El manager principal controla los mensajes y los despacha a los
  dem<65>s widgets. Cabe destacar que todo mensaje enviado a trav<61>s de
  jmanager_send_message no es procesado de inmediato, dicho mensaje
  solo se guardar<61> en una cola para luego ser despachado (si espera
  una respuesta inmediata, vea jmanager_dispatch_messages o
  jwidget_send_message).


  Foco de entrada (jmanager_get_focus):
    Es un puntero a un widget que indica que ser<65> el encargado de
    recibir la entrada del teclado. Por lo menos, ser<65> el primero en
    tener la oportunidad de procesarla, si <20>l no la utiliza, se enviar<61>
    el mensaje a otros widgets. El foco de entrada se mueve con la tecla
    TAB.

  Widget con el mouse (jmanager_get_mouse):
    Un puntero al widget que tiene el mouse encima.

  Widget con el mouse capturado (jmanager_get_capture):
    Un puntero al widget que captur<75> el mouse. Generalmente cuando se le
    hace click encima de un widget, <20>ste captura el mouse para que siga
    recibiendo la entrada del mouse hasta que el usuario suelte el
    bot<6F>n.



=========================================
============ Rutinas B<>sicas ============
=========================================

void *jmalloc  (unsigned long n_bytes);
void *jmalloc0 (unsigned long n_bytes);
void *jrealloc (void *mem, unsigned long n_bytes);
void  jfree    (void *mem);
  Equivalentes a malloc, calloc, realloc, y free respectivamente.

#define jnew(struct_type, n_structs)
#define jnew0(struct_type, n_structs)
#define jrenew(struct_type, mem, n_structs)
  Equivalente a usar:

    struct_type *mem1 = malloc (sizeof (struct_type) * n_structs).



================================
============ Widget ============
================================

  Los widgets son los componentes, objetos o controles del interfaz
  gr<67>fico; un bot<6F>n, o una ventana son ejemplos de widgets. En Jinete,
  el tipo JWidget representa dicho controles:

    typedef struct jwidget *JWidget;

  Es decir que JWidget en realidad se trata de un puntero a una
  estructura jwidget definida en el archivo "jinete/widget.h".

  En general, la gran mayor<6F>a de los tipos en Jinete (definidos en
  "jinete/base.h") se tratan de punteros a estructuras definidas en
  cada uno de los archivos de cabecera particulares.

  Para modificar el comportamiento de un widget, se deben agregar
  ganchos ("hooks", JHook en Jinete), los cuales se encargan de
  interceptar mensajes.

  Los campos de la estructura jwidget son:

  JID id;
    C<>digo de identificaci<63>n. Es un n<>mero con el cual puede identificar
    a un widget (por lo menos mientras <20>ste exista). Al liberar el widget
    (con jwidget_free), su ID quedar<61> disponible para un pr<70>ximo widget
    que se cree (mediante jwidget_new).

  int type;
    Tipo de widget. Puede ser JI_WIDGET para indicar un tipo de widget
    an<61>nimo, o puede ser JI_BUTTON si se cre<72> desde jbutton_new, o
    JI_WINDOW si se utiliz<69> jwindow_new, etc.

    Es el valor que se le pasa a la funci<63>n jwidget_new (puede tratarse
    de un valor devuelto por ji_register_widget_type).

  char *name;
    Nombre del widget (generalmente NULL si no es que es un widget
    cargado desde un archivo .jid). Es <20>til para buscar el widget
    desde su padre utilizando la rutina jwidget_find_name.

  JRect pos;
    Ubicaci<63>n del widget: esquina superior-izquierda (x, y) y tama<6D>o (w, h).
    Es una posici<63>n ABSOLUTA en la pantalla, NO ES UNA POSICI<43>N RELATIVA.

  struct { int l, t, r, b; } border_width;
    Tama<6D>o de los bordes izquierdo, superior, derecho e inferior (left,
    top, right, bottom).

  int child_spacing;
    Separaci<63>n entre los hijos del widget.

  int flags;
    Banderas o propiedades del widget.

  int emit_signals;
    Contador que indica si el widget debe o no generar se<73>ales (si
    emit_signals es igual a 0, las se<73>ales se emiten).

  int static_w, static_h;
    Tama<6D>o est<73>tico del widget por defecto (si es que no se intercepta
    el mensaje JM_REQSIZE, se utilizar<61> este tama<6D>o como el tama<6D>o
    necesario por el widget).

  JList children;
    Lista de widgets hijos. Son los controles que est<73>n contenidos en
    este widget. La funci<63>n jwidget_add_child sirve para agregar hijos
    dentro de un widget.

  JTheme theme;
    Tema o estilo que utiliza el widget (inicializ<69>ndolo al tema por
    defecto a trav<61>s de la funci<63>n ji_get_theme).

  JWidget parent;
    Puntero al widget padre.

  JList hooks;
    Lista de ganchos (JHook).

  JDrawWidget draw_method;
    Funci<63>n encargada de dibujar el widget, al inicializar un widget,
    se intenta extraer desde el tema activo (ji_get_theme) un m<>todo
    correspondiente para este tipo de widget (widget->draw_type).

    Si el mensaje JM_DRAW no es interceptado, esta rutina ser<65> utilizada
    para dibujar el widget.

  int align;
    Alineamiento u orientaci<63>n del widget (generalmente alineaci<63>n del texto).

  int text_size;
  char *text;
    Texto del widget.

  FONT *text_font;
    Tipo de fuente para dibujar texto (este campo es inicializado con
    el valor "ji_get_theme ()->default_font").

  int bg_color;
    Color de fondo del widget (si es -1, se utiliza el del padre, y as<61>
    sucesivamente).

  BITMAP *icon;
    <20>cono del widget (XXX).

  int icon_align;
    Alineamiento del <20>cono (XXX).

  void *theme_data[4];
    Datos para el tema.

  void *user_data[4];
    Datos para el usuario.



int ji_register_widget_type (void);
  Retorna un n<>mero entero positivo para identificar un nuevo tipo de
  widget. Deber<65>a utilizarlo s<>lo si necesita conocer en alguna parte
  de su c<>digo que un determinado widget es del tipo que deber<65>a ser.

  Retornar<61> valores continuos a JI_USER_WIDGET.

JWidget jwidget_new (int type);
  Crea un nuevo "widget" de tipo "type" listo para ser utilizado.

void jwidget_free (JWidget widget);
  Libera el "widget", dejando su espacio disponible para pr<70>ximos
  controles que as<61> lo necesiten. Note que esta funci<63>n no libera
  memoria, solo deja su espacio disponible para que otro posible
  futuro widget lo utilice. S<>lo la funci<63>n _ji_free_all_widgets
  libera toda la memoria ocupada por todos los widgets. Dicha funci<63>n
  es llamada al borrar el primer "manager" creado.

  Los widgets hijos tambi<62>n son eliminados (recursivamente). El campo
  "widget->specific_data" tambi<62>n es eliminado (mediante jfree).

  Env<6E>a el mensaje JM_DESTROY al widget inmediatamente.

void jwidget_init_theme (JWidget widget);
  Inicializa el widget a su tema (estilo) correspondiente haciendo uso
  de la funci<63>n init_widget de la estructura jtheme.

void jwidget_add_hook (JWidget widget, int type,
                         JMessageFunc msg_proc, void *data);
  Crea un nuevo gancho (hook) para interceptar mensajes.  Cada gancho
  tiene un tipo ("type"), que puede ser an<61>nimo (JI_WIDGET) o puede
  ser de un tipo personalizado (alg<6C>n tipo devuelto mediante
  ji_register_widget_type). Este tipo luego es utilizado para obtener
  los datos "data".

  El "msg_proc" es un puntero a una funci<63>n encargada de recibir cada
  mensaje y procesarlo. Esta funci<63>n debe retornar FALSE si no utiliza
  un determinado mensaje y/o quiere dejarle el paso a un posible
  "msg_proc" padre que se encuentre en el widget.

JHook jwidget_get_hook (JWidget widget, int type);

void *jwidget_get_data (JWidget widget, int type);

int jwidget_get_type (JWidget widget);
  Devuelve el tipo de widget que es "widget". Puede ser igual a
  JI_WIDGET si se trata de un tipo an<61>nimo de widget, o alguno de los
  widgets est<73>ndares (como JI_BOX, JI_BUTTON, JI_WINDOW, etc.), o
  finalmente deber<65>a tratarse de alg<6C>n tipo creado por el usuario
  mediante ji_register_widget_type ().

const char *jwidget_get_name (JWidget widget);
  Obtiene el nombre del widget. Generalmente los widgets nunca tendr<64>n
  nombre al menos que sean cargados desde un archivo .jid.

const char *jwidget_get_text (JWidget widget);
  Retorna un puntero al texto actual del widget, el cual puede ser
  tanto una etiqueta que lleve un bot<6F>n, el t<>tulo de una ventana,
  etc.

  No utilice el puntero si es que lo consigui<75> antes de una llamada a
  jwidget_set_text. EVITE SIEMPRE hacer esto:

    const char *text = jwidget_get_text (widget);
    jwidget_set_text (widget, "Hola");
    printf (text);

int jwidget_get_align (JWidget widget);
  Devuelve el alineamiento del widget (widget->align).

FONT *jwidget_get_font (JWidget widget);

void jwidget_set_name (JWidget widget, const char *name);
  Cambia el nombre del widget, generalmente <20>til si piensa luego usar
  jwidget_find_name desde otra funci<63>n o gancho.

void jwidget_set_text (JWidget widget, const char *text);
  Cambia el texto del widget. Est<73> funci<63>n tambi<62>n se encarga de
  ensuciar el widget mediante jwidget_dirty.

void jwidget_set_align (JWidget widget, int align);
  Cambia el alineamiento del widget (widget->align = align).

void jwidget_set_font (JWidget widget, FONT *font);

void jwidget_magnetic (JWidget widget, bool state);
  Cambia el estado de magnetismo del widget. Un widget magn<67>tica es
  la que obtiene el foco de entrada por defecto. Generalmente los
  botones de "Aceptar" o "Continuar" suelen tener esta propiedad,
  teniendo la posibilidad de capturar la tecla  y utilizarla
  para suponer que se quiso presionar dicho bot<6F>n (sin necesidad de
  poseer el foco de entrada).

void jwidget_expansive (JWidget widget, bool state);
  Cambia el estado de expansi<73>n del widget. Un widget expansivo es
  el que acapara mayor espacio en el widget padre. <20>til <20>nicamente
  cuando el widget padre es una caja (box).

void jwidget_decorative (JWidget widget, bool state);
  Cambia el estado de decoraci<63>n del widget. Un widget decorativo es
  un objeto especial el cual sirve para decorar las ventanas. S<>lo
  los temas deber<65>an utilizar esta funci<63>n, ya que es <20>til para
  agregar un bot<6F>n que cierre la ventana, o para minimizarla, o
  para maximizarla/restaurarla, etc.

void jwidget_autodestroy (JWidget widget, bool state);

void jwidget_focusrest (JWidget widget, bool state);

bool jwidget_is_magnetic (JWidget widget);
bool jwidget_is_expansive (JWidget widget);
bool jwidget_is_decorative (JWidget widget);
bool jwidget_is_autodestroy (JWidget widget);
  Devuelve TRUE si el widget es lo que preguntamos que sea (magn<67>tica,
  expansiva, decorativa, o autodestructiva).

bool jwidget_is_focusrest (JWidget widget);

void jwidget_dirty (JWidget widget);
  Ensucia el widget para que sea redibujado en una pr<70>xima llamada a
  jmanager_poll. S<>lo colocar<61> una bandera que le dir<69> al manager
  que genere los mensajes necesarios para dibujar las partes visibles
  del widget. Emite la se<73>al JM_DIRTY.

  Si desea redibujar un widget de forma instant<6E>nea:

    jwidget_dirty (widget);
    jwidget_flush_redraw (widget);
    jmanager_dispatch_draw_messages ();

  Tenga en cuenta, que muchas funciones que cambian el estado del
  widget, suelen llamar a jwidget_dirty para redibujar el widget con
  su nuevo estado.

void jwidget_show (JWidget widget);
void jwidget_hide (JWidget widget);

void jwidget_enable (JWidget widget);
void jwidget_disable (JWidget widget);

void jwidget_select (JWidget widget);
void jwidget_deselect (JWidget widget);

bool jwidget_is_visible (JWidget widget);
bool jwidget_is_hidden (JWidget widget);

bool jwidget_is_enabled (JWidget widget);
bool jwidget_is_disabled (JWidget widget);

bool jwidget_is_selected (JWidget widget);
bool jwidget_is_deselected (JWidget widget);

bool jwidget_has_focus (JWidget widget);
bool jwidget_has_mouse (JWidget widget);
bool jwidget_has_capture (JWidget widget);

void jwidget_add_child (JWidget widget, JWidget child);
  Agrega un nuevo widget hijo "child" dentro del widget padre
  "widget".

  Emite la se<73>al JI_SIGNAL_NEW_PARENT para "child", y
  JI_SIGNAL_ADD_CHILD para "widget".

void jwidget_add_childs (JWidget widget, ...);

void jwidget_remove_child (JWidget widget, JWidget child);

void jwidget_replace_child (JWidget widget, JWidget old, JWidget new);

JWidget jwidget_get_parent (JWidget widget);
  Devuelve un puntero al widget padre. Es equivalente a utilizar
  widget->parent directamente.

JWidget jwidget_get_window (JWidget widget);
  Recorre los padres del widget hasta encontrar la ventana a la que
  pertenece, devolviendo dicho puntero o NULL si es que no se pudo
  encontrar una ventana padre.

JList jwidget_get_parents (JWidget widget, bool ascendant);
  Retornar una list de los padres de "widget". Si "ascendant" es TRUE
  retorna desde el widget hasta el padre. Si "ascendant" es FALSE
  retorna desde el padre hasta "widget".

  Deber<65> liberar la lista devuelta mediante jlist_free.

JList jwidget_get_children (JWidget widget);

  Deber<65> liberar la lista devuelta mediante jlist_free.

JWidget jwidget_pick (JWidget widget, int x, int y);
  Busca un widget dentro de "widget" que se encuentre en la posici<63>n
  (x, y), partiendo desde el "widget", pasando por todos sus hijos.

  Devolver<65> el widget m<>s lejano de "widget" (el hijo m<>s profundo) si
  es que <20>ste se abarca el punto (x, y).

bool jwidget_has_child (JWidget widget, JWidget child);
  Devuelve TRUE si el "widget" posee dentro el widget hijo "child".
  Est<73> funci<63>n s<>lo mira por los hijos de "widget", nunca baja a los
  hijos de sus hijos.

void jwidget_request_size (JWidget widget, int *w, int *h);

JRect jwidget_get_position (JWidget widget);
  Retorna la posici<63>n del widget.

  El rect<63>ngulo devuelto JRect deber<65> ser liberado mediante jrect_free.

JRect jwidget_get_child_position (JWidget widget);

JRegion jwidget_get_region (JWidget widget);

  Deber<65> liberar la regi<67>n devuelta mediante jregion_free.

JRegion jwidget_get_drawable_region (JWidget widget, int flags);

  Deber<65> liberar la regi<67>n devuelta mediante jregion_free.

int jwidget_get_bg_color (JWidget widget);
  Devuelve el color de fondo de este widget (o si es -1 pregunta por
  el color del padre).

JTheme jwidget_get_theme (JWidget widget);
  Devuelve un puntero al tema que utiliza dicho widget.

int jwidget_get_text_length (JWidget widget);
int jwidget_get_text_height (JWidget widget);
  Retorna las medidas del texto del widget en p<>xeles. Puede ser
  equivalente a utilizar:

    int length = ji_font_text_len (widget->text_font, widget->text);
    int height = text_height (widget->text_font);

void jwidget_get_texticon_info (JWidget widget,
                                  JRect box, JRect text, JRect icon,
                                  int icon_w, int icon_h);

void jwidget_noborders (JWidget widget);

void jwidget_set_border (JWidget widget, int l, int t, int r, int b);

void jwidget_set_position (JWidget widget, JRect rect);

void jwidget_set_static_size (JWidget widget, int w, int h);

void jwidget_set_bg_color (JWidget widget, int color);

void jwidget_set_theme (JWidget widget, JTheme theme);

void jwidget_flush_redraw (JWidget widget);

void jwidget_redraw_region (JWidget widget, const JRegion region);

void jwidget_signal_on (JWidget widget);
void jwidget_signal_off (JWidget widget);

int jwidget_emit_signal (JWidget widget, int signal_num);

bool jwidget_send_message (JWidget widget, JMessage msg);

bool jwidget_send_message_after_type (JWidget widget,
                                        JMessage msg, int type);

void jwidget_close_window (JWidget widget);

void jwidget_capture_mouse (JWidget widget);
void jwidget_hard_capture_mouse (JWidget widget);

void jwidget_release_mouse (JWidget widget);

JWidget jwidget_find_name (JWidget widget, const char *name);
  Busca por el widget hijo con el nombre "name" dentro del widget
  "widget". <20>til para obtener widgets hijos cargados desde un archivo
  .jid.

bool jwidget_check_underscored (JWidget widget, int ascii);

Widget's flags
--------------

  Valores posibles para las banderas widget->flags. Evite usar estos
  valores directamente, en su lugar intente usar las funciones
  "jwidget_is_..." donde sea posible.

  JI_DIRTY
    El widget est<73> "sucio" (necesita ser redibujado en su totalidad).

  JI_HIDDEN
    El widget est<73> escondido.

  JI_SELECTED
    El widget est<73> seleccinado.

  JI_DISABLED
    El widget est<73> deshabilitado.

  JI_HASFOCUS
    El widget tiene el foco de entrada (o alguno de sus hijos lo
    tiene). Esta bandera s<>lo la pueden conseguir widgets que sean
    JI_FOCUSREST.

  JI_HASMOUSE
    El widget tiene el mouse (o alguno de sus hijos lo tiene).

  JI_HASCAPTURE
    El widget tiene el mouse capturado.

  JI_FOCUSREST
    El widget es un descanso para el foco, es decir, puede recibir el
    foco de entrada ya que lo utilizar<61> para algo. Por ejemplo: un bot<6F>n
    es focus-rest, pero una etiqueta (label) o una caja (box) no lo son.

  JI_MAGNETIC
    El widget es magn<67>tico (recibe el foco de entrada por defecto).

  JI_EXPANSIVE
    El widget es expansivo: intenta obtener el mayor lugar posible si su
    padre es una caja (box).

  JI_DECORATIVE
    El widget es decorativo (ver jwidget_decorative).

  JI_AUTODESTROY
    El widget es auto-destructivo (ver jwidget_autodestroy).

  JI_HARDCAPTURE
    El widget captur<75> el mouse en una forma "dura". Cuando se utiliza
    jwidget_hard_capture_mouse, el widget con el mouse
    (jmanager_get_mouse) ser<65> siempre el mismo widget que captur<75> el
    mouse, es imposible que cambie a otro widget.

    Cuando utiliza jwidget_capture_mouse, el widget con el mouse puede
    cambiar a otro widget, pero los mensajes del mouse siguen siendo
    enviados al que posee la captura.



========================================
============ JHook (gancho) ============
========================================


int type;

JMessageFunc msg_proc;
  Funci<63>n encargada de procesar los mensajes, debe retornar TRUE si el
  mensaje se utiliz<69> y no se desea que el mismo sea procesado por los
  siguientes "ganchos" consecutivos, o FALSE en caso contrario.

void *data;



===========================================
============ Message (mensaje) ============
===========================================

  Cuando se genera un mensaje, al ser despachado se comienza enviando
  el mismo a los ganchos de los widgets receptores, comenzando del
  primer gancho (el cual ser<65>a el <20>ltimo gancho agregado) hasta el
  <20>ltimo gancho del widget.

  Recuerde que si intercepta un mensaje, debe retornar TRUE indicando
  que el mensaje fue utilizado, as<61> frena el enviado de mensajes a
  otros ganchos.  Esto es v<>lido para todos los mensajes menos para
  JM_DESTROY.  Ya que devolviendo TRUE, los ganchos pr<70>ximos no
  recibir<69>n dicho mensaje y es posible que algo de memoria no se
  libere.

JM_OPEN
-------

  Es enviado a todos los widgets de una ventana cuando est<73> es abierta
  en un determinado manager.

JM_CLOSE
--------

  Cuando una ventana es cerrada, este mensaje se env<6E>a a todos los
  widgets de la misma.

JM_DESTROY
----------

  Se env<6E>a al eliminar el widget mediante jwidget_free. Un widget
  recibe una <20>nica vez este mensaje (siendo adem<65>s el <20>ltimo mensaje
  que recibir<69>). Recuerde retornar FALSE para no frenar el env<6E>o del
  mensaje a los ganchos pr<70>ximos.

JM_DRAW
-------

JM_IDLE
-------

JM_SIGNAL
---------

JM_REQSIZE
----------

  Mensaje utilizado para obtener el tama<6D>o necesario para el widget.
  Debe rellenar las variables msg->reqsize.w y msg->reqsize.h, y
  retornar TRUE si as<61> lo hizo.

JM_SETPOS
---------

  Mensaje utilizado para cambiar el tama<6D>o del widget, si lo intercepta,
  deber<65> hacer un "jrect_copy (widget->pos, &msg->setpos.rect)".

  Enganchar este mensaje es <20>til solamente si piensa reacomodar los
  hijos cada vez que cambie la posici<63>n del widget (es decir, siempre
  que un widget acepte hijos, deber<65> hacer su propio comportamiento
  para acomodar el widget y a sus respectivos widgets hijos).

JM_DRAWRGN
----------

  Puede cambiar la forma de redibujar una regi<67>n de un widget
  (jwidget_redraw_region). Por ahora s<>lo los managers necesitan
  interceptar este mensaje.

JM_DIRTYCHILDREN
----------------

  Tambi<62>n puede cambiar la forma de "ensuciar" los widgets hijos.  Por
  ejemplo, las list-boxes (cuadros de lista) necesitan enganchar este
  mensaje para redibujar <20>nicamente los <20>tems que est<73>n dentro del
  <20>rea de visible (para optimizar la velocidad de proceso).

JM_CHAR
-------

JM_KEYPRESSED
-------------

JM_KEYRELEASED
--------------

JM_FOCUSENTER
-------------

JM_FOCUSLEAVE
-------------

JM_BUTTONPRESSED
----------------

JM_BUTTONRELEASED
-----------------

JM_DOUBLECLICK
--------------

JM_MOUSEENTER
-------------

JM_MOUSELEAVE
-------------

JM_MOTION
---------

JM_WHEEL
--------



==========================================
============ Signal (se<73>ales) ============
==========================================

  Las se<73>ales son un buen m<>todo de enganchar determinadas funciones
  que controlan a las widgets. Es decir que podemos saber cuando
  ocurre determinado cambio en un widget (por ejemplo si un widget fue
  eliminado, o si un bot<6F>n cambio de estado).

JI_SIGNAL_DIRTY
---------------

  Se envia cuando un widget determinado es ensuciado.

JI_SIGNAL_ENABLE
----------------

  Al cambiar el estado de un widget a activado.

JI_SIGNAL_DISABLE
-----------------

  Al cambiar el estado de un widget a desactivado.

JI_SIGNAL_SELECT
----------------

JI_SIGNAL_DESELECT
------------------

JI_SIGNAL_SHOW
--------------

JI_SIGNAL_HIDE
--------------

JI_SIGNAL_ADD_CHILD
-------------------

JI_SIGNAL_REMOVE_CHILD
----------------------

JI_SIGNAL_NEW_PARENT
--------------------

JI_SIGNAL_GET_TEXT
------------------

JI_SIGNAL_SET_TEXT
------------------

JI_SIGNAL_INIT_THEME
--------------------

JI_SIGNAL_CHECK_CHANGE
----------------------

JI_SIGNAL_RADIO_CHANGE
----------------------

JI_SIGNAL_ENTRY_CHANGE
----------------------

JI_SIGNAL_LISTBOX_CHANGE
------------------------

JI_SIGNAL_LISTBOX_SELECT
------------------------

JI_SIGNAL_MENUITEM_SELECT
-------------------------

JI_SIGNAL_SLIDER_CHANGE
-----------------------



==========================================
============ Manager (gestor) ============
==========================================

JWidget ji_get_default_manager (void);
  Retorna un puntero del manager principal, el primer manager creado
  con jmanager_new.

JWidget jmanager_new (void);

void jmanager_free (JWidget manager);

void jmanager_run (JWidget manager);

bool jmanager_poll (JWidget manager, bool all_windows);

void jmanager_send_message (const JMessage msg);

JWidget jmanager_get_focus (void);

JWidget jmanager_get_mouse (void);

JWidget jmanager_get_capture (void);

void jmanager_set_focus (JWidget widget);

void jmanager_set_mouse (JWidget widget);

void jmanager_set_capture (JWidget widget);

void jmanager_attract_focus (JWidget widget);

void jmanager_free_focus (void);
void jmanager_free_mouse (void);
void jmanager_free_capture (void);

void jmanager_free_widget (JWidget widget);

void jmanager_remove_message (JMessage msg);

void jmanager_remove_messages_for (JWidget widget);

void jmanager_refresh_screen (void);

void jmanager_dispatch_messages (void);

void jmanager_dispatch_draw_messages (void);

void jmanager_open_window (JWidget manager, JWidget window);

void jmanager_close_window (JWidget manager, JWidget window, bool sendtokill);

JI_SIGNAL_MANAGER_EXTERNAL_CLOSE
--------------------------------

JI_SIGNAL_MANAGER_ADD_WINDOW
----------------------------

JI_SIGNAL_MANAGER_REMOVE_WINDOW
-------------------------------

JI_SIGNAL_MANAGER_IDLE
----------------------

JI_SIGNAL_MANAGER_LOSTCHAR
--------------------------



==========================================
============ Window (ventana) ============
==========================================

  Una ventana es un tipo de widget especial en una caja rectangular que
  representa un cuadro de di<64>logo (entre el usuario y el programa) el
  cual el usuario puede mover o cambiar de tama<6D>o a su antojo.

  En Jinete, la ventana incluye s<>lo los rebordes y la barra de t<>tulo,
  usted debe agregarle los widgets hijos mediante jwidget_add_child.
  La posici<63>n de los hijos es puesta en el <20>rea cliente (el <20>rea dentro
  de los bordes de la ventana), por lo que deber<65> agregar s<>lo un widget
  dentro de la ventana (generalmente una caja (box)) la cual contendr<64>
  los dem<65>s widgets.

JWidget jwindow_new (const char *text);
  Crea una nueva ventana con el texto "text" en la barra de t<>tulo.

JWidget jwindow_new_desktop (void);
  Crea una nueva ventana de tipo desktop (escritorio). Los escritorios
  ocupan toda la pantalla (o mejor dicho, todo el tama<6D>o del manager
  padre).

JWidget jwindow_get_killer (JWidget window);
  Devuelve el puntero al widget que "mat<61>" (cerr<72>) la ventana
  "window". Puede que este puntero sea NULL en el caso de que alg<6C>n
  ente an<61>nimo haya cerrado la ventana (como el bot<6F>n "x" para
  cerrarla, o la tecla ).

JWidget jwindow_get_manager (JWidget window);
  Devuelve el manager en el cual la ventana "window" se encuentra
  dentro.

void jwindow_mobile (JWidget window, bool mobile);
  Cambia el estado de movilidad de la ventana "window". Si una ventana
  es m<>vil, significa que el usuario puede cambiarle la posici<63>n y su
  tama<6D>o.

void jwindow_remap (JWidget window);
  XXX

  Esta funci<63>n generalmente no es necesaria utilizarla si usted usa
  jwindow_center o jwindow_position antes. Ser<65> necesaria en casos
  especiales donde usted necesite saber el tama<6D>o m<>nimo que necesita
  la ventana antes de abrirla.

void jwindow_center (JWidget window);
  Cambia la posici<63>n de la ventana "window" al centro el manager
  principal (el manager principal tiene el tama<6D>o de la pantalla
  f<>sica, o mejor dicho, del modo de video actual).

void jwindow_position (JWidget window, int x, int y);
  Posiciona la ventana a otro punto (x, y). Note que esta funci<63>n
  difiere de jwidget_set_position en el sentido de que s<>lo desplaza
  la ventana (y sus widgets hijos) a la nueva posici<63>n.

void jwindow_open (JWidget window);
  Abre la ventana en el manager por defecto para ser procesadas por
  pr<70>ximas llamadas a jmanager_poll.

  No deber<65>a usar esta funci<63>n a menos que sepa lo que est<73>
  haciendo. Generalmente nunca la deber<65> llamar directamente, en
  cambio, las funciones jwindow_open_fg o jwindow_open_bg son las
  com<6F>nmente utilizadas (y las mismas suelen utilizar jwindow_open).

void jwindow_open_fg (JWidget window);
  Abre la ventana en primer plano (foreground), paralizando las dem<65>s
  ventanas abiertas, y esperando una respuesta del usuario
  inmediata. Cuando la ventana se cierra se vuelve a donde la funci<63>n
  se llam<61>.

  <20>til cuando necesita hacer cosas como:

    jwindow_open_fg (window);
    if (jwindow_get_killer (window) == boton_aceptar) {
      ...
    }
    jwidget_free (window);

void jwindow_open_bg (JWidget window);
  Abre la ventana y la deja ejecut<75>ndose en segundo plano
  (background).

  Esta funci<63>n s<>lo coloca la bandera auto-destroy a la ventana y
  llama a la funci<63>n jwindow_open. La bandera auto-destroy hace que
  la ventana, al ser cerrada, sea autom<6F>ticamente liberada
  (jwidget_free) por el mismo manager antes que por nosotros.

void jwindow_close (JWidget window, JWidget killer);
  Cierra la ventana "window" forzosamente. El paramentro "killer"
  indica quien "mat<61>" (cerr<72>) la ventana, esto es debido a que esta
  funci<63>n generalmente se utiliza dentro de un "msg_proc" de un widget
  especial que se encarga de cerrar la ventana (por ejemplo un bot<6F>n,
  que al presionarlo, su acci<63>n por defecto es matar a su ventana
  padre).

bool jwindow_is_toplevel (JWidget window);
  Retorna TRUE si la ventana "window" se encuentra encima de todas las
  ventanas.

bool jwindow_is_foreground (JWidget window);
  Retorna TRUE si la ventana se ejecuta en primer plano (foreground).

bool jwindow_is_desktop (JWidget window);
  Retorna TRUE si la ventana es de tipo escritorio (desktop).

JI_SIGNAL_WINDOW_CLOSE
----------------------

JI_SIGNAL_WINDOW_RESIZE
-----------------------


====================================
============ Box (caja) ============
====================================

  Una caja (box) es uno de los widgets m<>s sencillos de manejar y a su
  vez, uno de los m<>s <20>tiles. Sirve para disponer los widgets hijos de
  forma horizontal o vertical, acomod<6F>ndolos a nuestro antojo, pero sin
  tener que preocuparnos por el tama<6D>o que necesita cada widget
  en particular.

JWidget jbox_new (int align);
  Crea una nueva caja (box) con las propiedades de alineamiento de "align".

  "align" debe poseer uno de estos dos valores:

  JI_HORIZONTAL o JI_VERTICAL:
    Indica si queremos ordenar los widgets de forma horizontal o
    vertical respectivamente.

  Y puede o no estar en combinaci<63>n con:

  JI_HOMOGENEOUS
    Indica que todos los widgets hijos deben poseer el mismo tama<6D>o.
    Generalmente el m<>ximo tama<6D>o necesario por el widget hijo m<>s
    grande que se encuentre dentro de la caja (box).




==========================================
============ Label (etiqueta) ============
==========================================

JWidget jlabel_new (const char *text);
  Crea una nueva widget de tipo etiqueta (label) con el texto "text".
  Las etiquetas sirven para mostrar un mensaje, o indicar qu<71>
  significa un widget de al lado.



========================================
============ Button (bot<6F>n) ============
========================================

  Un bot<6F>n es un widget que al ser presionado cierra la ventana donde
  est<73>, <20> ejecuta alguna acci<63>n o comando (como abrir otra nueva ventana).

  Un bot<6F>n, sin que usted intercepte ninguna se<73>al, ni mensaje,
  siempre cerrar<61> la ventana, tal es as<61>, que luego puede preguntar
  por jwindow_get_killer() y le devolver<65> un puntero a dicho bot<6F>n.

  Hay muchas formas de cambiar este comportamiento por defecto, la m<>s
  c<>moda es utilizando las funciones ji_button_add_command, as<61> la
  ventana no ser<65> cerrada y en su lugar se llamar<61> al comando
  especificado.  Tambi<62>n, utilizando jwidget_add_hook() puede
  interceptar el mensaje JM_SIGNAL cuando se env<6E>a la se<73>al
  JI_SIGNAL_BUTTON_SELECT.

  Para que no queden dudas, cuando un bot<6F>n es presionado:

    Primero se env<6E>a la se<73>al JI_SIGNAL_BUTTON_SELECT

    Si retorna FALSE, significa que la se<73>al no fue utilizada, por lo
    tanto debemos ejecutar el comportamiento por defecto: si se agregaron
    comandos al bot<6F>n mediante jbutton_add_command(), se ejecutar<61>n los
    comandos, ahora, si el bot<6F>n no tiene comando alguno, se cerrar<61> la
    ventana.

JWidget jbutton_new (const char *text);
  Crea un nuevo bot<6F>n con el texto "text". Recuerde que por defecto,
  si es que no agrega ning<6E>n comando, los botones cierran la ventana

  Puede saber que bot<6F>n cerr<72> la ventana utilizando jwindow_get_killer.

void jbutton_set_icon (JWidget button, struct BITMAP *icon);

void jbutton_set_icon_align (JWidget button, int icon_align);

void jbutton_set_bevel (JWidget button, int b0, int b1, int b2, int b3);

void jbutton_get_bevel (JWidget button, int *b4);

void jbutton_add_command (JWidget button,
                            void (*command) (JWidget button));

void jbutton_add_command_data (JWidget button,
                                 void (*command) (JWidget button,
                                                  void *data),
                                 void *data);

JI_SIGNAL_BUTTON_SELECT
-----------------------

  Esta se<73>al se env<6E>a a los handlers del bot<6F>n cuando el mismo es
  presionado (seleccionado).  Deber<65> retornar TRUE para indicar que
  utiliz<69> dicha se<73>al, si es que no quiere ejecutar el comportamiento
  por defecto del bot<6F>n: llamar los comandos si es que existen o
  cerrar la ventana en caso contrario.



======================================================
============ Check (caja de comprobaci<63>n) ============
======================================================

JWidget jcheck_new (const char *text);
  Crea una nueva caja de comprobaci<63>n. Sirven para representar
  opciones booleanas (valores verdadero o falso).

void jcheck_set_icon_align (JWidget check, int icon_align);



======================================
============ Theme (tema) ============
======================================



======================================
============ Archivos JID ============
======================================

  En un archivo .jid puede definir la estructura de una ventana (o de
  cualquier tipo de widget).

  Ejemplo:

  En "archivo.jid":

    <window desktop name="ventana1" text="Mi Ventana">
      <box vertical>
        <label expansive name="mensaje" text="Su mensaje" />
        <box horizontal homogeneous>
          <button text="&Aceptar" name="boton_aceptar" />
          <button text="&Cancelar" />
        </box>
      </box>
    </window>

  En un "archivo.c":

    JWidget ventana1 = ji_load_widget ("archivo.jid", "ventana1");
    JWidget boton_aceptar = jwidget_find_name (ventana1, "boton_aceptar");

    jwindow_open_fg (ventana1);
    if (jwindow_get_killer (ventana1) == boton_aceptar) {
      ...
    }


JWidget ji_load_widget (const char *filename, const char *name);



=======================================
============ Font (fuente) ============
=======================================

FONT *ji_font_load (const char *filepathname);

int ji_font_get_size (FONT *f);

int ji_font_set_size (FONT *f, int height);

int ji_font_get_aa_mode (FONT *f);

int ji_font_set_aa_mode (FONT *f, int mode);

bool ji_font_is_fixed (FONT *f);
bool ji_font_is_scalable (FONT *f);

const int *ji_font_get_available_fixed_sizes (FONT *f, int *n);

int ji_font_get_char_extra_spacing (FONT *f);

void ji_font_set_char_extra_spacing (FONT *f, int spacing);

int ji_font_char_len (FONT *f, int chr);
  Retorna la longitud (ancho) de un caracter en pixeles.

int ji_font_text_len (FONT *f, const char *text);
  Retorna la longitud (ancho) del texto "text" en pixeles. Recuerde
  que esta funci<63>n interpreta el caracter '&' como un subrayado.
  Ejemplo: La longitud "&OK" es igual a la de "OK".



==================================================
============ JList - Listas Enlazadas ============
==================================================

  Las listas enlazadas se manejan a trav<61>s de los punteros JList:

    typedef struct jlist *JList;

  La estructura jlist se define:

    struct jlist
    {
      void *data;
      JList next;
      JList prev;
    };

  La mayor<6F>a de funciones reciben como primer par<61>metro el puntero al
  primer elemento de la lista (el cual puede estar apuntado a NULL) y
  devuelven un nuevo puntero (por las dudas si la cabecera cambi<62>).

  Por ejemplo:

    JList lista = NULL;
    lista = jlist_append (lista, (void *)2);
    lista = jlist_append (lista, (void *)3);
    lista = jlist_prepend (lista, (void *)1);
    jlist_free (lista);

  Generar<61> la lista (1, 2, 3).

  (Nota: si alguna vez program<61> con la librer<65>a GLib, las funciones
   g_list_* hacen ex<65>ctamente lo mismo que sus respectivas jlist_*).

JList jlist_alloc (void);

void jlist_free (JList list);
  Libera la memoria utilizada por toda la lista "list". Esta funci<63>n no
  borra los datos contenidos en cada nodo (se supone que antes de
  llamar esta rutina, usted ya se encarg<72> de eso).

void jlist_free_1 (JList list);
  Libera la memoria utilizada <20>nicamente por el nodo "list". Esta
  funci<63>n no borra los datos contenidos en el puntero list->data.

JList jlist_append (JList list, void *data);
  Agrega un nuevo elemento con los datos "data" al final de la lista.

JList jlist_prepend (JList list, void *data);
  Agrega un nuevo elemento con los datos "data" al comienzo de la lista.

JList jlist_insert (JList list, void *data, int position);

JList jlist_insert_sorted (JList list, void *data, JCompareFunc func);

JList jlist_insert_before (JList list, JList sibling, void *data);

JList jlist_concat (JList list1, JList list2);

JList jlist_remove (JList list, const void *data);
  Remueve la primer ocurrencia de "data" en la lista recorri<72>ndola
  hacia delante. El nodo es eliminado (mediante free), los datos no.

JList jlist_remove_all (JList list, const void *data);
  Remueve todas las ocurrencias de "data" en la lista recorri<72>ndola
  hacia delante. Los nodos son eliminados (mediante free), los datos
  no.

JList jlist_remove_link (JList list, JList llink);
  Remueve el nodo "llink" de la lista "list". El nodo NO es liberado
  (aqu<71> se supone que luego usted llamar<61> un jlist_free_1).

JList jlist_delete_link (JList list, JList link);
  Remueve el nodo "link" de la lista "list". El nodo ser<65> eliminado,
  los datos no.

JList jlist_reverse (JList list);

JList jlist_copy (JList list);
  Copia la lista generando una completamente nueva con cada elemento
  apuntado a los mismos datos que la anterior lista.

JList jlist_nth (JList list, unsigned int n);

JList jlist_nth_prev (JList list, unsigned int n);

JList jlist_find (JList list, const void *data);
  Busca el nodo en el cual se encuentra los datos "data".

  Esta funci<63>n recorre desde "list" hacia delante.

JList jlist_find_custom (JList list, const void *data, JCompareFunc func);

int jlist_position (JList list, JList llink);
  Devuelve la posici<63>n (el <20>ndice) en que se encuentra el nodo
  "llink". Siendo list la posici<63>n 0, list->next la 1,
  list->next->next la 2, etc.

  Retorna -1 si no se encontr<74>.

int jlist_index (JList list, const void *data);
  Devuelve el <20>ndice en que se encuentra el nodo con los datos
  "data". Siendo list el <20>ndice 0, list->next el 1, list->next->next
  el 2, etc.

  Retorna -1 si no se encontr<74>.

JList jlist_last (JList list);
  Retorna un puntero al <20>ltimo elemento de la lista (puede devolver
  NULL si list es NULL).

JList jlist_first (JList list);
  Retorna el primer elemento de la lista (esta funci<63>n est<73> hecha por
  las dudas si "list" no apunta ya al primer elemento).

unsigned int jlist_length (JList list);
  Retorna la cantidad de nodos que contiene la lista "list".

void jlist_foreach (JList list, JFunc func, void *user_data);
  Por cada nodo de la lista "list" llamar<61> a la funci<63>n "func".
  El Ejemplo:

    void mi_funcion (void *data, void *user_data)
    {
      printf ("%d\n", (int)data);
    }

    ...

    JList lista = NULL;
    lista = jlist_append (lista, (void *)2);
    lista = jlist_append (lista, (void *)3);
    lista = jlist_prepend (lista, (void *)1);
    jlist_foreach (lista, mi_funcion, NULL);
    jlist_free (lista);

  Imprime:

    1
    2
    3

JList jlist_sort (JList list, JCompareFunc compare_func);

JList jlist_sort_with_data (JList list,
                              JCompareDataFunc compare_func,
                              void *user_data);

void *jlist_nth_data (JList list, unsigned int n);

#define jlist_previous(list)
#define jlist_next(list)
  Devuelve el anterior o el siguiente nodo del elemento "list" de una
  lista cualquiera. Utilizar esta funci<63>n es lo mismo que usar
  list->prev o list->next, con la <20>nica diferencia que antes se hace
  un chequeo de que list sea distinto de NULL.



=============================================
============ JRect - Rect<63>ngulos ============
=============================================


    struct jrect
    {
      int x, y, w, h;
    };

JRect jrect_new (int x, int y, int w, int h);

JRect jrect_new_copy (const JRect rect);

void jrect_free (JRect rect);

void jrect_copy (JRect dst, const JRect src);

void jrect_replace (JRect rect, int x, int y, int w, int h);

void jrect_add (JRect rect, const JRect other);

bool jrect_intersect (JRect rect, const JRect other);

void jrect_shrink (JRect rect, int border);

void jrect_stretch (JRect rect, int border);

#define jrect_has_intersection(rect, other)



============================================
============ JRegion - Regiones ============
============================================

  En Jinete, una regi<67>n es un conjunto de rect<63>ngulos, una lista
  enlazada de rect<63>ngulos.

    typedef struct jregion JRegion;

    struct jregion
    {
      JList rects;
    };

JRegion jregion_new (void);
  Crea una nueva regi<67>n vac<61>a. Usted deber<65> eliminar la regi<67>n
  devuelta mediante jregion_free.

JRegion jregion_new_copy (const JRegion region);
  Crea una nueva copia de region. Usted deber<65> eliminar la regi<67>n
  devuelta mediante jregion_free.

void jregion_free (JRegion region);

void jregion_clear (JRegion region);

void jregion_move (JRegion region, int x, int y);

void jregion_join (JRegion region, JRegion other);

void jregion_add (JRegion region, const JRect rect);

void jregion_subtract (JRegion region, const JRect rect);

void jregion_intersect (JRegion region, const JRect rect);

void jregion_add2 (JRegion region, const JRegion other);

void jregion_subtract2 (JRegion region, const JRegion other);

void jregion_intersect2 (JRegion region, const JRegion other);



============================================
============ Funciones Internas ============
============================================

JWidget _ji_get_widget_by_id (JID widget_id);

JWidget *_ji_get_widget_array (int *nwidgets);
  Devuelve un puntero al arreglo interno que maneja todos los widgets.
  A "nwidgets" le ser<65> asignado la cantidad de elementos del arreglo de
  widgets.

JWidget _ji_get_new_widget (void);

void _ji_free_widget (JWidget widget);
  Libera el widget para que pueda ser utilizado por otro nuevo
  widget. Esta funci<63>n no borra nada del widget, es utilizada por
  jwidget_free, as<61> que no deber<65>a utilizarla NUNCA.

void _ji_free_all_widgets (void);
  Libera la memoria utilizada por todas las widgets. Nunca llame esta
  funci<63>n directamente.  Usted no deber<65>a preocuparse por utilizarla
  debido a que se llama internamente cuando sea necesario (cuando se
  elimina el primer "manager" creado).

bool _ji_is_valid_widget (JWidget widget);

int _ji_system_init (void);
void _ji_system_exit (void);

int _ji_font_init (void);
void _ji_font_exit (void);

bool _jwindow_is_moving (void);
  Devuelve TRUE si en este momento el usuario est<73> moviendo una
  ventana.



=========================================
============ Actualizaciones ============
=========================================

  Jinete comenz<6E> con Allegro Sprite Editor (ASE) y continuar<61> muy cerca
  de <20>l. Vea la p<>gina de ASE para tener noticias sobre esta librer<65>a:

    http://ase.sourceforge.net/

  Si quiere saber m<>s sobre el autor:

    http://www.davidcapello.com.ar/



=========================================
============ Agradecimientos ============
=========================================

  Gracias a:

    Shawn Hargreaves y a todos los que ayudaron con Allegro.

    Richard M. Stallman y todo el mundo que participa en las proyectos GNU
    como GCC, Emacs, etc.

    David Turner, Robert Wilhelm, y Werner Lemberg por The FreeType library.