This is the Info version of the Jinete manual

By David A. Capello

                            Jinete 0.4

                           A GUI library.

                      By David A. Capello, 2005.

#include <std_disclaimer.h>

"No me responsabilizo de ningú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ón
************

Jinete es una librería que proporciona un Interfaz Gráfico de Usuario (GUI por sus siglas en inglés), sencilla y rápida tanto de usar, como de programar y diseñar diálogos.  Conjuntamente con la librería Allegro, se encarga de controlar los eventos que produce el usuario a través del rató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ón con él, sería bonito que mencionase Jinete en alguna parte de los créditos, pero no está obligado a hacerlo.

Funcionamiento General
**********************

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

Jinete es controlado con el manager principal, el cual es creado por primera y única vez a través de la primer llamada de jmanager_new, y deberá 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í como la MDI de Windows).

El manager principal controla los mensajes y los despacha a los demás widgets. Cabe destacar que todo mensaje enviado a través de jmanager_send_message no es procesado de inmediato, dicho mensaje solo se guardará 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á el encargado de recibir la entrada del teclado. Por lo menos, será el primero en tener la oportunidad de procesarla, si él no la utiliza, se enviará 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ó el mouse. Generalmente cuando se le hace click encima de un widget, éste captura el mouse para que siga recibiendo la entrada del mouse hasta que el usuario suelte el botón.

See also:

See jmanager_new.

See ji_manager_free.

See jmanager_send_message.

See ji_manager_dispatch_messages.

Rutinas Básicas
***************

jmalloc
=======

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.

jnew
====

#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áfico; un botó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í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ón. Es un número con el cual puede identificar a un widget (por lo menos mientras éste exista). Al liberar el widget (con jwidget_free), su ID quedará disponible para un próximo widget que se cree (mediante jwidget_new).

  * int type;

     Tipo de widget. Puede ser JI_WIDGET para indicar un tipo de widget anónimo, o puede ser JI_BUTTON si se creó desde jbutton_new, o JI_WINDOW si se utilizó jwindow_new, etc.

     Es el valor que se le pasa a la funció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 útil para buscar el widget desde su padre utilizando la rutina jwidget_find_name.

  * JRect pos;

     Ubicación del widget: esquina superior-izquierda (x, y) y tamaño (w, h). Es una posición ABSOLUTA en la pantalla, NO ES UNA POSICIÓN RELATIVA.

  * struct { int l, t, r, b; } border_width;

     Tamaño de los bordes izquierdo, superior, derecho e inferior (left, top, right, bottom).

  * int child_spacing;

     Separació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ñales (si emit_signals es igual a 0, las señales se emiten).

  * int static_w, static_h;

     Tamaño estático del widget por defecto (si es que no se intercepta el mensaje JM_REQSIZE, se utilizará este tamaño como el tamaño necesario por el widget).

  * JList children;

     Lista de widgets hijos. Son los controles que están contenidos en este widget. La función jwidget_add_child sirve para agregar hijos dentro de un widget.

  * JTheme theme;

     Tema o estilo que utiliza el widget (inicializándolo al tema por defecto a través de la función ji_get_theme).

  * JWidget parent;

     Puntero al widget padre.

  * JList hooks;

     Lista de ganchos (JHook).

  * JDrawWidget draw_method;

     Funció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á utilizada para dibujar el widget.

  * int align;

     Alineamiento u orientación del widget (generalmente alineació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í sucesivamente).

  * BITMAP *icon;

     Ícono del widget (XXX).

  * int icon_align;

     Alineamiento del ícono (XXX).

  * void *theme_data[4];

     Datos para el tema.

  * void *user_data[4];

     Datos para el usuario.

ji_register_widget_type
=======================

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

     Retornará valores continuos a JI_USER_WIDGET.

jwidget_new
===========

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

See also:

See jwidget_free.

jwidget_free
============

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

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

     Envía el mensaje JM_DESTROY al widget inmediatamente.

See also:

See jwidget_new.

See _ji_free_all_widgets.

See Manager.

See JM_DESTROY.

jwidget_init_theme
==================

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

jwidget_add_hook
================

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ónimo (JI_WIDGET) o puede ser de un tipo personalizado (algú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ón encargada de recibir cada mensaje y procesarlo. Esta funció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.

See also:

See ji_register_widget_type.

See jwidget_get_hook.

See jwidget_get_data.

jwidget_get_hook
================

JHook jwidget_get_hook (JWidget widget, int type);

jwidget_get_data
================

void *jwidget_get_data (JWidget widget, int type);

jwidget_get_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ónimo de widget, o alguno de los widgets estándares (como JI_BOX, JI_BUTTON, JI_WINDOW, etc.), o finalmente debería tratarse de algún tipo creado por el usuario mediante ji_register_widget_type ().

See also:

See ji_register_widget_type.

jwidget_get_name
================

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

See also:

See jwidget_set_name.

See ji_load_widget.

See Archivos JID.

jwidget_get_text
================

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ón, el título de una ventana, etc.

     No utilice el puntero si es que lo consiguió 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);

See also:

See jwidget_set_text.

jwidget_get_align
=================

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

See also:

See jwidget_set_align.

jwidget_get_font
================

FONT *jwidget_get_font (JWidget widget);

jwidget_set_name
================

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

See also:

See jwidget_find_name.

jwidget_set_text
================

void jwidget_set_text (JWidget widget, const char *text);
     Cambia el texto del widget. Está función también se encarga de ensuciar el widget mediante jwidget_dirty.

See also:

See jwidget_get_text.

See jwidget_dirty.

jwidget_set_align
=================

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

See also:

See jwidget_get_align.

jwidget_set_font
================

void jwidget_set_font (JWidget widget, FONT *font);

jwidget_magnetic
================

void jwidget_magnetic (JWidget widget, bool state);
     Cambia el estado de magnetismo del widget. Un widget magné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ón (sin necesidad de poseer el foco de entrada).

See also:

See jwidget_is_magnetic.

See jmanager_attract_focus.

jwidget_expansive
=================

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

See also:

See jwidget_is_expansive.

See jbox_new.

jwidget_decorative
==================

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

See also:

See jwidget_is_decorative.

See Window (ventana).

See Theme (tema).

jwidget_autodestroy
===================

void jwidget_autodestroy (JWidget widget, bool state);

jwidget_focusrest
=================

void jwidget_focusrest (JWidget widget, bool state);

jwidget_is_magnetic
===================

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ética, expansiva, decorativa, o autodestructiva).

See also:

See jwidget_magnetic.

See jwidget_expansive.

See jwidget_decorative.

See jwidget_autodestroy.

jwidget_is_focusrest
====================

bool jwidget_is_focusrest (JWidget widget);

See also:

See jwidget_focusrest.

jwidget_dirty
=============

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

     Si desea redibujar un widget de forma instantá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.

See also:

See jmanager_poll.

See JI_SIGNAL_DIRTY.

jwidget_show
============

void jwidget_show (JWidget widget);

void jwidget_hide (JWidget widget);

jwidget_enable
==============

void jwidget_enable (JWidget widget);

void jwidget_disable (JWidget widget);

jwidget_select
==============

void jwidget_select (JWidget widget);

void jwidget_deselect (JWidget widget);

jwidget_is_visible
==================

bool jwidget_is_visible (JWidget widget);

bool jwidget_is_hidden (JWidget widget);

jwidget_is_enabled
==================

bool jwidget_is_enabled (JWidget widget);

bool jwidget_is_disabled (JWidget widget);

jwidget_is_selected
===================

bool jwidget_is_selected (JWidget widget);

bool jwidget_is_deselected (JWidget widget);

jwidget_has_focus
=================

bool jwidget_has_focus (JWidget widget);

bool jwidget_has_mouse (JWidget widget);

bool jwidget_has_capture (JWidget widget);

jwidget_add_child
=================

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

     Emite la señal JI_SIGNAL_NEW_PARENT para "child", y JI_SIGNAL_ADD_CHILD para "widget".

See also:

See jwidget_remove_child.

See jwidget_replace_child.

See JI_SIGNAL_NEW_PARENT.

See JI_SIGNAL_ADD_CHILD.

jwidget_add_childs
==================

void jwidget_add_childs (JWidget widget, ...);

See also:

See jwidget_add_child.

jwidget_remove_child
====================

void jwidget_remove_child (JWidget widget, JWidget child);

See also:

See jwidget_add_child.

See jwidget_replace_child.

jwidget_replace_child
=====================

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

See also:

See jwidget_add_child.

See jwidget_remove_child.

jwidget_get_parent
==================

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

See also:

See jwidget_get_parents.

jwidget_get_window
==================

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.

See also:

See jwindow_get_manager.

jwidget_get_parents
===================

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á liberar la lista devuelta mediante jlist_free.

See also:

See jwidget_get_parent.

See jlist_free.

jwidget_get_children
====================

JList jwidget_get_children (JWidget widget);

     Deberá liberar la lista devuelta mediante jlist_free.

jwidget_pick
============

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

     Devolverá el widget más lejano de "widget" (el hijo más profundo) si es que éste se abarca el punto (x, y).

jwidget_has_child
=================

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

jwidget_request_size
====================

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

jwidget_get_position
====================

JRect jwidget_get_position (JWidget widget);
     Retorna la posición del widget.

     El rectángulo devuelto JRect deberá ser liberado mediante jrect_free.

See also:

See jwidget_get_region.

See jrect_free.

jwidget_get_child_position
==========================

JRect jwidget_get_child_position (JWidget widget);

jwidget_get_region
==================

JRegion jwidget_get_region (JWidget widget);

     Deberá liberar la región devuelta mediante jregion_free.

See also:

See jwidget_get_position.

See jwidget_get_drawable_region.

See jregion_free.

jwidget_get_drawable_region
===========================

JRegion jwidget_get_drawable_region (JWidget widget, int flags);

     Deberá liberar la región devuelta mediante jregion_free.

See also:

See jwidget_get_region.

See jregion_free.

jwidget_get_bg_color
====================

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).

jwidget_get_theme
=================

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

jwidget_get_text_length
=======================

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);

See also:

See ji_font_text_len.

jwidget_get_texticon_info
=========================

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

jwidget_noborders
=================

void jwidget_noborders (JWidget widget);

jwidget_set_border
==================

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

jwidget_set_position
====================

void jwidget_set_position (JWidget widget, JRect rect);

jwidget_set_static_size
=======================

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

jwidget_set_bg_color
====================

void jwidget_set_bg_color (JWidget widget, int color);

jwidget_set_theme
=================

void jwidget_set_theme (JWidget widget, JTheme theme);

jwidget_flush_redraw
====================

void jwidget_flush_redraw (JWidget widget);

jwidget_redraw_region
=====================

void jwidget_redraw_region (JWidget widget, const JRegion region);

jwidget_signal_on
=================

void jwidget_signal_on (JWidget widget);

void jwidget_signal_off (JWidget widget);

jwidget_emit_signal
===================

int jwidget_emit_signal (JWidget widget, int signal_num);

jwidget_send_message
====================

bool jwidget_send_message (JWidget widget, JMessage msg);

jwidget_send_message_after_type
===============================

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

jwidget_close_window
====================

void jwidget_close_window (JWidget widget);

jwidget_capture_mouse
=====================

void jwidget_capture_mouse (JWidget widget);

void jwidget_hard_capture_mouse (JWidget widget);

jwidget_release_mouse
=====================

void jwidget_release_mouse (JWidget widget);

jwidget_find_name
=================

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

See also:

See jwidget_set_name.

See Archivos JID.

jwidget_check_underscored
=========================

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á "sucio" (necesita ser redibujado en su totalidad).

       * JI_HIDDEN

          El widget está escondido.

       * JI_SELECTED

          El widget está seleccinado.

       * JI_DISABLED

          El widget está 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á para algo. Por ejemplo: un botón es focus-rest, pero una etiqueta (label) o una caja (box) no lo son.

       * JI_MAGNETIC

          El widget es magné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ó el mouse en una forma "dura". Cuando se utiliza jwidget_hard_capture_mouse, el widget con el mouse (jmanager_get_mouse) será siempre el mismo widget que capturó 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.

See also:

See jwidget_decorative.

See jwidget_autodestroy.

See jwidget_hard_capture_mouse.

JHook (gancho)
**************

  * int type;

  * JMessageFunc msg_proc;

     Función encargada de procesar los mensajes, debe retornar TRUE si el mensaje se utilizó 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ía el último gancho agregado) hasta el último gancho del widget.

Recuerde que si intercepta un mensaje, debe retornar TRUE indicando que el mensaje fue utilizado, así 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óximos no recibirá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á es abierta en un determinado manager.

See also:

See JM_CLOSE.

JM_CLOSE
========

     Cuando una ventana es cerrada, este mensaje se envía a todos los widgets de la misma.

See also:

See JM_OPEN.

See JM_DESTROY.

JM_DESTROY
==========

     Se envía al eliminar el widget mediante jwidget_free. Un widget recibe una única vez este mensaje (siendo además el último mensaje que recibirá). Recuerde retornar FALSE para no frenar el envío del mensaje a los ganchos próximos.

See also:

See JM_CLOSE.

JM_DRAW
=======

JM_IDLE
=======

JM_SIGNAL
=========

JM_REQSIZE
==========

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

See also:

See jwidget_request_size.

JM_SETPOS
=========

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

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

See also:

See jwidget_set_position.

JM_DRAWRGN
==========

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

JM_DIRTYCHILDREN
================

     También puede cambiar la forma de "ensuciar" los widgets hijos.  Por ejemplo, las list-boxes (cuadros de lista) necesitan enganchar este mensaje para redibujar únicamente los ítems que estén dentro del á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ñales)
****************

Las señ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ón cambio de estado).

JI_SIGNAL_DIRTY
===============

     Se envia cuando un widget determinado es ensuciado.

See also:

See jwidget_dirty.

JI_SIGNAL_ENABLE
================

     Al cambiar el estado de un widget a activado.

See also:

See jwidget_enable.

JI_SIGNAL_DISABLE
=================

     Al cambiar el estado de un widget a desactivado.

See also:

See jwidget_disable.

JI_SIGNAL_SELECT
================

See also:

See jwidget_select.

JI_SIGNAL_DESELECT
==================

See also:

See jwidget_deselect.

JI_SIGNAL_SHOW
==============

See also:

See jwidget_show.

JI_SIGNAL_HIDE
==============

See also:

See jwidget_hide.

JI_SIGNAL_ADD_CHILD
===================

See also:

See jwidget_add_child.

JI_SIGNAL_REMOVE_CHILD
======================

See also:

See jwidget_remove_child.

JI_SIGNAL_NEW_PARENT
====================

See also:

See jwidget_add_child.

See jwidget_remove_child.

JI_SIGNAL_GET_TEXT
==================

See also:

See JI_SIGNAL_SET_TEXT.

JI_SIGNAL_SET_TEXT
==================

See also:

See JI_SIGNAL_GET_TEXT.

JI_SIGNAL_INIT_THEME
====================

See also:

See jwidget_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)
****************

ji_get_default_manager
======================

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

See also:

See jmanager_new.

jmanager_new
============

JWidget jmanager_new (void);

See also:

See jmanager_free.

jmanager_free
=============

void jmanager_free (JWidget manager);

See also:

See jmanager_new.

jmanager_run
============

void jmanager_run (JWidget manager);

See also:

See jmanager_poll.

jmanager_poll
=============

bool jmanager_poll (JWidget manager, bool all_windows);

See also:

See jmanager_run.

jmanager_send_message
=====================

void jmanager_send_message (const JMessage msg);

See also:

See jmanager_dispatch_messages.

jmanager_get_focus
==================

JWidget jmanager_get_focus (void);

See also:

See jmanager_set_focus.

jmanager_get_mouse
==================

JWidget jmanager_get_mouse (void);

See also:

See jmanager_set_mouse.

jmanager_get_capture
====================

JWidget jmanager_get_capture (void);

See also:

See jmanager_set_capture.

jmanager_set_focus
==================

void jmanager_set_focus (JWidget widget);

See also:

See jmanager_get_focus.

jmanager_set_mouse
==================

void jmanager_set_mouse (JWidget widget);

See also:

See jmanager_get_mouse.

jmanager_set_capture
====================

void jmanager_set_capture (JWidget widget);

See also:

See jmanager_get_capture.

jmanager_attract_focus
======================

void jmanager_attract_focus (JWidget widget);

See also:

See jwidget_magnetic.

jmanager_free_focus
===================

void jmanager_free_focus (void);

void jmanager_free_mouse (void);

void jmanager_free_capture (void);

See also:

See jmanager_set_focus.

See ji_manager_set_mouse.

See ji_manager_set_capture.

jmanager_free_widget
====================

void jmanager_free_widget (JWidget widget);

jmanager_remove_message
=======================

void jmanager_remove_message (JMessage msg);

jmanager_remove_messages_for
============================

void jmanager_remove_messages_for (JWidget widget);

jmanager_refresh_screen
=======================

void jmanager_refresh_screen (void);

jmanager_dispatch_messages
==========================

void jmanager_dispatch_messages (void);

jmanager_dispatch_draw_messages
===============================

void jmanager_dispatch_draw_messages (void);

jmanager_open_window
====================

void jmanager_open_window (JWidget manager, JWidget window);

jmanager_close_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álogo (entre el usuario y el programa) el cual el usuario puede mover o cambiar de tamañ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ón de los hijos es puesta en el área cliente (el área dentro de los bordes de la ventana), por lo que deberá agregar sólo un widget dentro de la ventana (generalmente una caja (box)) la cual contendrá los demás widgets.

jwindow_new
===========

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

jwindow_new_desktop
===================

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ño del manager padre).

See also:

See jwindow_is_desktop.

jwindow_get_killer
==================

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

See also:

See jwindow_close.

jwindow_get_manager
===================

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

See also:

See jwindow_open.

See jmanager_open_window.

jwindow_mobile
==============

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ón y su tamaño.

jwindow_remap
=============

void jwindow_remap (JWidget window);
     XXX

     Esta función generalmente no es necesaria utilizarla si usted usa jwindow_center o jwindow_position antes. Será necesaria en casos especiales donde usted necesite saber el tamaño mínimo que necesita la ventana antes de abrirla.

jwindow_center
==============

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

See also:

See jwindow_position.

jwindow_position
================

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

jwindow_open
============

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

     No debería usar esta función a menos que sepa lo que está haciendo. Generalmente nunca la deberá llamar directamente, en cambio, las funciones jwindow_open_fg o jwindow_open_bg son las comúnmente utilizadas (y las mismas suelen utilizar jwindow_open).

See also:

See jwindow_open_fg.

See jwindow_open_bg.

See ji_get_default_manager.

See jmanager_poll.

jwindow_open_fg
===============

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

     Útil cuando necesita hacer cosas como:

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

See also:

See jwindow_open_bg.

See jwindow_get_killer.

See jwidget_free.

jwindow_open_bg
===============

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

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

See also:

See jwindow_open.

See jwindow_open_fg.

See jwidget_free.

See jwidget_autodestroy.

jwindow_close
=============

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

See also:

See jwindow_open.

See jwindow_get_killer.

jwindow_is_toplevel
===================

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

jwindow_is_foreground
=====================

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

See also:

See jwindow_open_fg.

jwindow_is_desktop
==================

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

See also:

See jwindow_new_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 útiles. Sirve para disponer los widgets hijos de forma horizontal o vertical, acomodándolos a nuestro antojo, pero sin tener que preocuparnos por el tamaño que necesita cada widget en particular.

jbox_new
========

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ón con:

       * JI_HOMOGENEOUS

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

Label (etiqueta)
****************

jlabel_new
==========

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é significa un widget de al lado.

Button (botón)
**************

Un botón es un widget que al ser presionado cierra la ventana donde está, ó ejecuta alguna acción o comando (como abrir otra nueva ventana).

Un botón, sin que usted intercepte ninguna señal, ni mensaje, siempre cerrará la ventana, tal es así, que luego puede preguntar por jwindow_get_killer() y le devolverá un puntero a dicho botón.

Hay muchas formas de cambiar este comportamiento por defecto, la más cómoda es utilizando las funciones ji_button_add_command, así la ventana no será cerrada y en su lugar se llamará al comando especificado.  También, utilizando jwidget_add_hook() puede interceptar el mensaje JM_SIGNAL cuando se envía la señal JI_SIGNAL_BUTTON_SELECT.

Para que no queden dudas, cuando un botón es presionado:

  * Primero se envía la señal JI_SIGNAL_BUTTON_SELECT

  * Si retorna FALSE, significa que la señal no fue utilizada, por lo tanto debemos ejecutar el comportamiento por defecto: si se agregaron comandos al botón mediante jbutton_add_command(), se ejecutarán los comandos, ahora, si el botón no tiene comando alguno, se cerrará la ventana.

jbutton_new
===========

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

     Puede saber que botón cerró la ventana utilizando jwindow_get_killer.

See also:

See jbutton_add_command.

See jwindow_get_killer.

jbutton_set_icon
================

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

jbutton_set_icon_align
======================

void jbutton_set_icon_align (JWidget button, int icon_align);

jbutton_set_bevel
=================

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

jbutton_get_bevel
=================

void jbutton_get_bevel (JWidget button, int *b4);

jbutton_add_command
===================

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

See also:

See jbutton_add_command_data.

See JI_SIGNAL_BUTTON_SELECT.

jbutton_add_command_data
========================

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

See also:

See jbutton_add_command.

See JI_SIGNAL_BUTTON_SELECT.

JI_SIGNAL_BUTTON_SELECT
=======================

     Esta señal se envía a los handlers del botón cuando el mismo es presionado (seleccionado).  Deberá retornar TRUE para indicar que utilizó dicha señal, si es que no quiere ejecutar el comportamiento por defecto del botón: llamar los comandos si es que existen o cerrar la ventana en caso contrario.

See also:

See Button (botón).

See jwidget_add_hook.

Check (caja de comprobación)
****************************

jcheck_new
==========

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

jcheck_set_icon_align
=====================

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) {
       ...
     }

ji_load_widget
==============

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

Font (fuente)
*************

ji_font_load
============

FONT *ji_font_load (const char *filepathname);

ji_font_get_size
================

int ji_font_get_size (FONT *f);

ji_font_set_size
================

int ji_font_set_size (FONT *f, int height);

ji_font_get_aa_mode
===================

int ji_font_get_aa_mode (FONT *f);

ji_font_set_aa_mode
===================

int ji_font_set_aa_mode (FONT *f, int mode);

ji_font_is_fixed
================

bool ji_font_is_fixed (FONT *f);

bool ji_font_is_scalable (FONT *f);

ji_font_get_available_fixed_sizes
=================================

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

ji_font_get_char_extra_spacing
==============================

int ji_font_get_char_extra_spacing (FONT *f);

ji_font_set_char_extra_spacing
==============================

void ji_font_set_char_extra_spacing (FONT *f, int spacing);

ji_font_char_len
================

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

ji_font_text_len
================

int ji_font_text_len (FONT *f, const char *text);
     Retorna la longitud (ancho) del texto "text" en pixeles. Recuerde que esta funció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és de los punteros JList:

     typedef struct jlist *JList;

La estructura jlist se define:

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

La mayoría de funciones reciben como primer pará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ó).

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á la lista (1, 2, 3).

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

jlist_alloc
===========

JList jlist_alloc (void);

jlist_free
==========

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

See also:

See jlist_free_1.

jlist_free_1
============

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

See also:

See jlist_free.

See ji_list_alloc.

jlist_append
============

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

jlist_prepend
=============

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

jlist_insert
============

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

jlist_insert_sorted
===================

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

jlist_insert_before
===================

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

jlist_concat
============

JList jlist_concat (JList list1, JList list2);

jlist_remove
============

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

jlist_remove_all
================

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

jlist_remove_link
=================

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

See also:

See jlist_delete_link.

See ji_list_free_1.

jlist_delete_link
=================

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

See also:

See jlist_remove_link.

jlist_reverse
=============

JList jlist_reverse (JList list);

jlist_copy
==========

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_nth
=========

JList jlist_nth (JList list, unsigned int n);

jlist_nth_prev
==============

JList jlist_nth_prev (JList list, unsigned int n);

jlist_find
==========

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

     Esta función recorre desde "list" hacia delante.

jlist_find_custom
=================

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

jlist_position
==============

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

     Retorna -1 si no se encontró.

See also:

See jlist_index.

jlist_index
===========

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

     Retorna -1 si no se encontró.

See also:

See jlist_position.

jlist_last
==========

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

jlist_first
===========

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

jlist_length
============

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

jlist_foreach
=============

void jlist_foreach (JList list, JFunc func, void *user_data);
     Por cada nodo de la lista "list" llamará a la funció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_sort
==========

JList jlist_sort (JList list, JCompareFunc compare_func);

jlist_sort_with_data
====================

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

jlist_nth_data
==============

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

jlist_previous
==============

#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ón es lo mismo que usar list->prev o list->next, con la única diferencia que antes se hace un chequeo de que list sea distinto de NULL.

JRect - Rectángulos
*******************

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

jrect_new
=========

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

See also:

See jrect_free.

jrect_new_copy
==============

JRect jrect_new_copy (const JRect rect);

See also:

See jrect_new.

See jrect_copy.

jrect_free
==========

void jrect_free (JRect rect);

See also:

See jrect_new.

jrect_copy
==========

void jrect_copy (JRect dst, const JRect src);

See also:

See jrect_new_copy.

jrect_replace
=============

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

jrect_add
=========

void jrect_add (JRect rect, const JRect other);

jrect_intersect
===============

bool jrect_intersect (JRect rect, const JRect other);

See also:

See jrect_has_intersection.

jrect_shrink
============

void jrect_shrink (JRect rect, int border);

See also:

See jrect_stretch.

jrect_stretch
=============

void jrect_stretch (JRect rect, int border);

See also:

See jrect_shrink.

jrect_has_intersection
======================

#define jrect_has_intersection(rect, other)

See also:

See jrect_intersect.

JRegion - Regiones
******************

En Jinete, una región es un conjunto de rectángulos, una lista enlazada de rectángulos.

     typedef struct jregion JRegion;

     struct jregion
     {
       JList rects;
     };

jregion_new
===========

JRegion jregion_new (void);
     Crea una nueva región vacía. Usted deberá eliminar la región devuelta mediante jregion_free.

See also:

See jregion_free.

jregion_new_copy
================

JRegion jregion_new_copy (const JRegion region);
     Crea una nueva copia de region. Usted deberá eliminar la región devuelta mediante jregion_free.

See also:

See jregion_new.

jregion_free
============

void jregion_free (JRegion region);

See also:

See jregion_new.

See ji_region_clear.

jregion_clear
=============

void jregion_clear (JRegion region);

See also:

See jregion_free.

jregion_move
============

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

jregion_join
============

void jregion_join (JRegion region, JRegion other);

jregion_add
===========

void jregion_add (JRegion region, const JRect rect);

jregion_subtract
================

void jregion_subtract (JRegion region, const JRect rect);

jregion_intersect
=================

void jregion_intersect (JRegion region, const JRect rect);

jregion_add2
============

void jregion_add2 (JRegion region, const JRegion other);

jregion_subtract2
=================

void jregion_subtract2 (JRegion region, const JRegion other);

jregion_intersect2
==================

void jregion_intersect2 (JRegion region, const JRegion other);

Funciones Internas
******************

_ji_get_widget_by_id
====================

JWidget _ji_get_widget_by_id (JID widget_id);

_ji_get_widget_array
====================

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

_ji_get_new_widget
==================

JWidget _ji_get_new_widget (void);

_ji_free_widget
===============

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

_ji_free_all_widgets
====================

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

_ji_is_valid_widget
===================

bool _ji_is_valid_widget (JWidget widget);

_ji_system_init
===============

int _ji_system_init (void);

void _ji_system_exit (void);

_ji_font_init
=============

int _ji_font_init (void);

void _ji_font_exit (void);

_jwindow_is_moving
==================

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

Actualizaciones
***************

Jinete comenzó con Allegro Sprite Editor (ASE) y continuará muy cerca de él. Vea la página de ASE para tener noticias sobre esta librerí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.

Índice
******