\input texinfo
@documentlanguage es
@setfilename jinete-es.info
@settitle Jinete Manual
@setchapternewpage odd
@paragraphindent 0
@setchapternewpage off

@ifinfo
@dircategory Libraries
@direntry
* Jinete: (jinete).                   A GUI library
@end direntry
This is the Info version of the Jinete manual

By David A. Capello
@end ifinfo

@node Top, , (dir), (dir)
@titlepage
@example

                       Jinete 0.4

                      A GUI library.

                 By David A. Capello, 2005.

@end example


#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."

@end titlepage
@ifinfo
@example

                       Jinete 0.4

                      A GUI library.

                 By David A. Capello, 2005.

@end example


#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."

@end ifinfo



@menu
* Introducción::            Introducción
* Copyright::               Copyright
* Funcionamiento::          Funcionamiento General
* Rutinas::                 Rutinas Básicas
* Widget::                  Widget
* JHook::                   JHook (gancho)
* Message::                 Message (mensaje)
* Signal::                  Signal (señales)
* Manager::                 Manager (gestor)
* Window::                  Window (ventana)
* Box::                     Box (caja)
* Label::                   Label (etiqueta)
* Button::                  Button (botón)
* Check::                   Check (caja de comprobación)
* Theme::                   Theme (tema)
* Archivos::                Archivos JID
* Font::                    Font (fuente)
* JList::                   JList - Listas Enlazadas
* JRect::                   JRect - Rectángulos
* JRegion::                 JRegion - Regiones
* Funciones::               Funciones Internas
* Actualizaciones::         Actualizaciones
* Agradecimientos::         Agradecimientos
* Índice::                  Índice
@end menu



@node Introducción, Copyright, , Top
@chapter 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.



@node Copyright, Funcionamiento, Introducción, Top
@chapter 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.



@node Funcionamiento, Rutinas, Copyright, Top
@chapter 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).


@itemize @bullet
@item 
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.
@item 
Widget con el mouse (jmanager_get_mouse):@*
Un puntero al widget que tiene el mouse encima.
@item 
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.
@end itemize



See also:@*
@xref{jmanager_new}.@*
@xref{ji_manager_free}.@*
@xref{jmanager_send_message}.@*
@xref{ji_manager_dispatch_messages}.@*
@node Rutinas, Widget, Funcionamiento, Top
@chapter Rutinas Básicas

@menu
* jmalloc::
* jnew::
@end menu
@node jmalloc, jnew, , Rutinas
@section jmalloc
@ftable @asis
@item @t{void *jmalloc  (unsigned long n_bytes);}
@end ftable
@ftable @asis
@item @t{void *jmalloc0 (unsigned long n_bytes);}
@end ftable
@ftable @asis
@item @t{void *jrealloc (void *mem, unsigned long n_bytes);}
@end ftable
@ftable @asis
@item @t{void  jfree    (void *mem);}
Equivalentes a malloc, calloc, realloc, y free respectivamente.

@end ftable
@node jnew, ji_register_widget_type, jmalloc, Rutinas
@section jnew
@ftable @asis
@item @t{#define jnew(struct_type, n_structs)}
@end ftable
@ftable @asis
@item @t{#define jnew0(struct_type, n_structs)}
@end ftable
@ftable @asis
@item @t{#define jrenew(struct_type, mem, n_structs)}
Equivalente a usar:
@example

struct_type *mem1 = malloc (sizeof (struct_type) * n_structs).
@end example



@end ftable
@node Widget, JHook, Rutinas, Top
@chapter 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:
@example

typedef struct jwidget *JWidget;
@end example

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:

@itemize @bullet
@item 
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).
@item 
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).
@item 
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.
@item 
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.
@item 
struct @{ int l, t, r, b; @} border_width;@*
Tamaño de los bordes izquierdo, superior, derecho e inferior (left,
top, right, bottom).
@item 
int child_spacing;@*
Separación entre los hijos del widget.
@item 
int flags;@*
Banderas o propiedades del widget.
@item 
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).
@item 
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).
@item 
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.
@item 
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).
@item 
JWidget parent;@*
Puntero al widget padre.
@item 
JList hooks;@*
Lista de ganchos (JHook).
@item 
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.
@item 
int align;@*
Alineamiento u orientación del widget (generalmente alineación del texto).
@item 
int text_size;@*
char *text;@*
Texto del widget.
@item 
FONT *text_font;@*
Tipo de fuente para dibujar texto (este campo es inicializado con
el valor "ji_get_theme ()->default_font").
@item 
int bg_color;@*
Color de fondo del widget (si es -1, se utiliza el del padre, y así
sucesivamente).
@item 
BITMAP *icon;@*
Ícono del widget (XXX).
@item 
int icon_align;@*
Alineamiento del ícono (XXX).
@item 
void *theme_data[4];@*
Datos para el tema.
@item 
void *user_data[4];@*
Datos para el usuario.
@end itemize



@menu
* ji_register_widget_type::
* jwidget_new::
* jwidget_free::
* jwidget_init_theme::
* jwidget_add_hook::
* jwidget_get_hook::
* jwidget_get_data::
* jwidget_get_type::
* jwidget_get_name::
* jwidget_get_text::
* jwidget_get_align::
* jwidget_get_font::
* jwidget_set_name::
* jwidget_set_text::
* jwidget_set_align::
* jwidget_set_font::
* jwidget_magnetic::
* jwidget_expansive::
* jwidget_decorative::
* jwidget_autodestroy::
* jwidget_focusrest::
* jwidget_is_magnetic::
* jwidget_is_focusrest::
* jwidget_dirty::
* jwidget_show::
* jwidget_enable::
* jwidget_select::
* jwidget_is_visible::
* jwidget_is_enabled::
* jwidget_is_selected::
* jwidget_has_focus::
* jwidget_add_child::
* jwidget_add_childs::
* jwidget_remove_child::
* jwidget_replace_child::
* jwidget_get_parent::
* jwidget_get_window::
* jwidget_get_parents::
* jwidget_get_children::
* jwidget_pick::
* jwidget_has_child::
* jwidget_request_size::
* jwidget_get_position::
* jwidget_get_child_position::
* jwidget_get_region::
* jwidget_get_drawable_region::
* jwidget_get_bg_color::
* jwidget_get_theme::
* jwidget_get_text_length::
* jwidget_get_texticon_info::
* jwidget_noborders::
* jwidget_set_border::
* jwidget_set_position::
* jwidget_set_static_size::
* jwidget_set_bg_color::
* jwidget_set_theme::
* jwidget_flush_redraw::
* jwidget_redraw_region::
* jwidget_signal_on::
* jwidget_emit_signal::
* jwidget_send_message::
* jwidget_send_message_after_type::
* jwidget_close_window::
* jwidget_capture_mouse::
* jwidget_release_mouse::
* jwidget_find_name::
* jwidget_check_underscored::
* Widget's flags::
@end menu
@node ji_register_widget_type, jwidget_new, jnew, Widget
@section ji_register_widget_type
@ftable @asis
@item @t{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.

@end ftable
@node jwidget_new, jwidget_free, ji_register_widget_type, Widget
@section jwidget_new
@ftable @asis
@item @t{JWidget jwidget_new (int type);}
Crea un nuevo "widget" de tipo "type" listo para ser utilizado.

@end ftable
See also:@*
@xref{jwidget_free}.@*
@node jwidget_free, jwidget_init_theme, jwidget_new, Widget
@section jwidget_free
@ftable @asis
@item @t{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.

@end ftable
See also:@*
@xref{jwidget_new}.@*
@xref{_ji_free_all_widgets}.@*
@xref{Manager}.@*
@xref{JM_DESTROY}.@*
@node jwidget_init_theme, jwidget_add_hook, jwidget_free, Widget
@section jwidget_init_theme
@ftable @asis
@item @t{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.

@end ftable
@node jwidget_add_hook, jwidget_get_hook, jwidget_init_theme, Widget
@section jwidget_add_hook
@ftable @asis
@item @t{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.

@end ftable
See also:@*
@xref{ji_register_widget_type}.@*
@xref{jwidget_get_hook}.@*
@xref{jwidget_get_data}.@*
@node jwidget_get_hook, jwidget_get_data, jwidget_add_hook, Widget
@section jwidget_get_hook
@ftable @asis
@item @t{JHook jwidget_get_hook (JWidget widget, int type);}

@end ftable
@node jwidget_get_data, jwidget_get_type, jwidget_get_hook, Widget
@section jwidget_get_data
@ftable @asis
@item @t{void *jwidget_get_data (JWidget widget, int type);}

@end ftable
@node jwidget_get_type, jwidget_get_name, jwidget_get_data, Widget
@section jwidget_get_type
@ftable @asis
@item @t{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 ().

@end ftable
See also:@*
@xref{ji_register_widget_type}.@*
@node jwidget_get_name, jwidget_get_text, jwidget_get_type, Widget
@section jwidget_get_name
@ftable @asis
@item @t{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.

@end ftable
See also:@*
@xref{jwidget_set_name}.@*
@xref{ji_load_widget}.@*
@xref{Archivos, Archivos JID}.@*
@node jwidget_get_text, jwidget_get_align, jwidget_get_name, Widget
@section jwidget_get_text
@ftable @asis
@item @t{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:
@example

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

@end ftable
See also:@*
@xref{jwidget_set_text}.@*
@node jwidget_get_align, jwidget_get_font, jwidget_get_text, Widget
@section jwidget_get_align
@ftable @asis
@item @t{int jwidget_get_align (JWidget widget);}
Devuelve el alineamiento del widget (widget->align).

@end ftable
See also:@*
@xref{jwidget_set_align}.@*
@node jwidget_get_font, jwidget_set_name, jwidget_get_align, Widget
@section jwidget_get_font
@ftable @asis
@item @t{FONT *jwidget_get_font (JWidget widget);}

@end ftable
@node jwidget_set_name, jwidget_set_text, jwidget_get_font, Widget
@section jwidget_set_name
@ftable @asis
@item @t{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.

@end ftable
See also:@*
@xref{jwidget_find_name}.@*
@node jwidget_set_text, jwidget_set_align, jwidget_set_name, Widget
@section jwidget_set_text
@ftable @asis
@item @t{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.

@end ftable
See also:@*
@xref{jwidget_get_text}.@*
@xref{jwidget_dirty}.@*
@node jwidget_set_align, jwidget_set_font, jwidget_set_text, Widget
@section jwidget_set_align
@ftable @asis
@item @t{void jwidget_set_align (JWidget widget, int align);}
Cambia el alineamiento del widget (widget->align = align).

@end ftable
See also:@*
@xref{jwidget_get_align}.@*
@node jwidget_set_font, jwidget_magnetic, jwidget_set_align, Widget
@section jwidget_set_font
@ftable @asis
@item @t{void jwidget_set_font (JWidget widget, FONT *font);}

@end ftable
@node jwidget_magnetic, jwidget_expansive, jwidget_set_font, Widget
@section jwidget_magnetic
@ftable @asis
@item @t{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).

@end ftable
See also:@*
@xref{jwidget_is_magnetic}.@*
@xref{jmanager_attract_focus}.@*
@node jwidget_expansive, jwidget_decorative, jwidget_magnetic, Widget
@section jwidget_expansive
@ftable @asis
@item @t{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).

@end ftable
See also:@*
@xref{jwidget_is_magnetic, jwidget_is_expansive}.@*
@xref{jbox_new}.@*
@node jwidget_decorative, jwidget_autodestroy, jwidget_expansive, Widget
@section jwidget_decorative
@ftable @asis
@item @t{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.

@end ftable
See also:@*
@xref{jwidget_is_magnetic, jwidget_is_decorative}.@*
@xref{Window, Window (ventana)}.@*
@xref{Theme, Theme (tema)}.@*
@node jwidget_autodestroy, jwidget_focusrest, jwidget_decorative, Widget
@section jwidget_autodestroy
@ftable @asis
@item @t{void jwidget_autodestroy (JWidget widget, bool state);}

@end ftable
@node jwidget_focusrest, jwidget_is_magnetic, jwidget_autodestroy, Widget
@section jwidget_focusrest
@ftable @asis
@item @t{void jwidget_focusrest (JWidget widget, bool state);}

@end ftable
@node jwidget_is_magnetic, jwidget_is_focusrest, jwidget_focusrest, Widget
@section jwidget_is_magnetic
@ftable @asis
@item @t{bool jwidget_is_magnetic (JWidget widget);}
@end ftable
@ftable @asis
@item @t{bool jwidget_is_expansive (JWidget widget);}
@end ftable
@ftable @asis
@item @t{bool jwidget_is_decorative (JWidget widget);}
@end ftable
@ftable @asis
@item @t{bool jwidget_is_autodestroy (JWidget widget);}
Devuelve TRUE si el widget es lo que preguntamos que sea (magnética,
expansiva, decorativa, o autodestructiva).

@end ftable
See also:@*
@xref{jwidget_magnetic}.@*
@xref{jwidget_expansive}.@*
@xref{jwidget_decorative}.@*
@xref{jwidget_autodestroy}.@*
@node jwidget_is_focusrest, jwidget_dirty, jwidget_is_magnetic, Widget
@section jwidget_is_focusrest
@ftable @asis
@item @t{bool jwidget_is_focusrest (JWidget widget);}

@end ftable
See also:@*
@xref{jwidget_focusrest}.@*
@node jwidget_dirty, jwidget_show, jwidget_is_focusrest, Widget
@section jwidget_dirty
@ftable @asis
@item @t{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:
@example

jwidget_dirty (widget);
jwidget_flush_redraw (widget);
jmanager_dispatch_draw_messages ();
@end example

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.

@end ftable
See also:@*
@xref{jmanager_poll}.@*
@xref{JI_SIGNAL_DIRTY}.@*
@node jwidget_show, jwidget_enable, jwidget_dirty, Widget
@section jwidget_show
@ftable @asis
@item @t{void jwidget_show (JWidget widget);}
@end ftable
@ftable @asis
@item @t{void jwidget_hide (JWidget widget);}

@end ftable
@node jwidget_enable, jwidget_select, jwidget_show, Widget
@section jwidget_enable
@ftable @asis
@item @t{void jwidget_enable (JWidget widget);}
@end ftable
@ftable @asis
@item @t{void jwidget_disable (JWidget widget);}

@end ftable
@node jwidget_select, jwidget_is_visible, jwidget_enable, Widget
@section jwidget_select
@ftable @asis
@item @t{void jwidget_select (JWidget widget);}
@end ftable
@ftable @asis
@item @t{void jwidget_deselect (JWidget widget);}

@end ftable
@node jwidget_is_visible, jwidget_is_enabled, jwidget_select, Widget
@section jwidget_is_visible
@ftable @asis
@item @t{bool jwidget_is_visible (JWidget widget);}
@end ftable
@ftable @asis
@item @t{bool jwidget_is_hidden (JWidget widget);}

@end ftable
@node jwidget_is_enabled, jwidget_is_selected, jwidget_is_visible, Widget
@section jwidget_is_enabled
@ftable @asis
@item @t{bool jwidget_is_enabled (JWidget widget);}
@end ftable
@ftable @asis
@item @t{bool jwidget_is_disabled (JWidget widget);}

@end ftable
@node jwidget_is_selected, jwidget_has_focus, jwidget_is_enabled, Widget
@section jwidget_is_selected
@ftable @asis
@item @t{bool jwidget_is_selected (JWidget widget);}
@end ftable
@ftable @asis
@item @t{bool jwidget_is_deselected (JWidget widget);}

@end ftable
@node jwidget_has_focus, jwidget_add_child, jwidget_is_selected, Widget
@section jwidget_has_focus
@ftable @asis
@item @t{bool jwidget_has_focus (JWidget widget);}
@end ftable
@ftable @asis
@item @t{bool jwidget_has_mouse (JWidget widget);}
@end ftable
@ftable @asis
@item @t{bool jwidget_has_capture (JWidget widget);}

@end ftable
@node jwidget_add_child, jwidget_add_childs, jwidget_has_focus, Widget
@section jwidget_add_child
@ftable @asis
@item @t{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".

@end ftable
See also:@*
@xref{jwidget_remove_child}.@*
@xref{jwidget_replace_child}.@*
@xref{JI_SIGNAL_NEW_PARENT}.@*
@xref{JI_SIGNAL_ADD_CHILD}.@*
@node jwidget_add_childs, jwidget_remove_child, jwidget_add_child, Widget
@section jwidget_add_childs
@ftable @asis
@item @t{void jwidget_add_childs (JWidget widget, ...);}

@end ftable
See also:@*
@xref{jwidget_add_child}.@*
@node jwidget_remove_child, jwidget_replace_child, jwidget_add_childs, Widget
@section jwidget_remove_child
@ftable @asis
@item @t{void jwidget_remove_child (JWidget widget, JWidget child);}

@end ftable
See also:@*
@xref{jwidget_add_child}.@*
@xref{jwidget_replace_child}.@*
@node jwidget_replace_child, jwidget_get_parent, jwidget_remove_child, Widget
@section jwidget_replace_child
@ftable @asis
@item @t{void jwidget_replace_child (JWidget widget, JWidget old, JWidget new);}

@end ftable
See also:@*
@xref{jwidget_add_child}.@*
@xref{jwidget_remove_child}.@*
@node jwidget_get_parent, jwidget_get_window, jwidget_replace_child, Widget
@section jwidget_get_parent
@ftable @asis
@item @t{JWidget jwidget_get_parent (JWidget widget);}
Devuelve un puntero al widget padre. Es equivalente a utilizar
widget->parent directamente.

@end ftable
See also:@*
@xref{jwidget_get_parents}.@*
@node jwidget_get_window, jwidget_get_parents, jwidget_get_parent, Widget
@section jwidget_get_window
@ftable @asis
@item @t{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.

@end ftable
See also:@*
@xref{jwindow_get_manager}.@*
@node jwidget_get_parents, jwidget_get_children, jwidget_get_window, Widget
@section jwidget_get_parents
@ftable @asis
@item @t{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.

@end ftable
See also:@*
@xref{jwidget_get_parent}.@*
@xref{jlist_free}.@*
@node jwidget_get_children, jwidget_pick, jwidget_get_parents, Widget
@section jwidget_get_children
@ftable @asis
@item @t{JList jwidget_get_children (JWidget widget);}

Deberá liberar la lista devuelta mediante jlist_free.

@end ftable
@node jwidget_pick, jwidget_has_child, jwidget_get_children, Widget
@section jwidget_pick
@ftable @asis
@item @t{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).

@end ftable
@node jwidget_has_child, jwidget_request_size, jwidget_pick, Widget
@section jwidget_has_child
@ftable @asis
@item @t{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.

@end ftable
@node jwidget_request_size, jwidget_get_position, jwidget_has_child, Widget
@section jwidget_request_size
@ftable @asis
@item @t{void jwidget_request_size (JWidget widget, int *w, int *h);}

@end ftable
@node jwidget_get_position, jwidget_get_child_position, jwidget_request_size, Widget
@section jwidget_get_position
@ftable @asis
@item @t{JRect jwidget_get_position (JWidget widget);}
Retorna la posición del widget.

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

@end ftable
See also:@*
@xref{jwidget_get_region}.@*
@xref{jrect_free}.@*
@node jwidget_get_child_position, jwidget_get_region, jwidget_get_position, Widget
@section jwidget_get_child_position
@ftable @asis
@item @t{JRect jwidget_get_child_position (JWidget widget);}

@end ftable
@node jwidget_get_region, jwidget_get_drawable_region, jwidget_get_child_position, Widget
@section jwidget_get_region
@ftable @asis
@item @t{JRegion jwidget_get_region (JWidget widget);}

Deberá liberar la región devuelta mediante jregion_free.

@end ftable
See also:@*
@xref{jwidget_get_position}.@*
@xref{jwidget_get_drawable_region}.@*
@xref{jregion_free}.@*
@node jwidget_get_drawable_region, jwidget_get_bg_color, jwidget_get_region, Widget
@section jwidget_get_drawable_region
@ftable @asis
@item @t{JRegion jwidget_get_drawable_region (JWidget widget, int flags);}

Deberá liberar la región devuelta mediante jregion_free.

@end ftable
See also:@*
@xref{jwidget_get_region}.@*
@xref{jregion_free}.@*
@node jwidget_get_bg_color, jwidget_get_theme, jwidget_get_drawable_region, Widget
@section jwidget_get_bg_color
@ftable @asis
@item @t{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).

@end ftable
@node jwidget_get_theme, jwidget_get_text_length, jwidget_get_bg_color, Widget
@section jwidget_get_theme
@ftable @asis
@item @t{JTheme jwidget_get_theme (JWidget widget);}
Devuelve un puntero al tema que utiliza dicho widget.

@end ftable
@node jwidget_get_text_length, jwidget_get_texticon_info, jwidget_get_theme, Widget
@section jwidget_get_text_length
@ftable @asis
@item @t{int jwidget_get_text_length (JWidget widget);}
@end ftable
@ftable @asis
@item @t{int jwidget_get_text_height (JWidget widget);}
Retorna las medidas del texto del widget en píxeles. Puede ser
equivalente a utilizar:
@example

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

@end ftable
See also:@*
@xref{ji_font_text_len}.@*
@node jwidget_get_texticon_info, jwidget_noborders, jwidget_get_text_length, Widget
@section jwidget_get_texticon_info
@ftable @asis
@item @t{void jwidget_get_texticon_info (JWidget widget, JRect box, JRect text, JRect icon, int icon_w, int icon_h);}

@end ftable
@node jwidget_noborders, jwidget_set_border, jwidget_get_texticon_info, Widget
@section jwidget_noborders
@ftable @asis
@item @t{void jwidget_noborders (JWidget widget);}

@end ftable
@node jwidget_set_border, jwidget_set_position, jwidget_noborders, Widget
@section jwidget_set_border
@ftable @asis
@item @t{void jwidget_set_border (JWidget widget, int l, int t, int r, int b);}

@end ftable
@node jwidget_set_position, jwidget_set_static_size, jwidget_set_border, Widget
@section jwidget_set_position
@ftable @asis
@item @t{void jwidget_set_position (JWidget widget, JRect rect);}

@end ftable
@node jwidget_set_static_size, jwidget_set_bg_color, jwidget_set_position, Widget
@section jwidget_set_static_size
@ftable @asis
@item @t{void jwidget_set_static_size (JWidget widget, int w, int h);}

@end ftable
@node jwidget_set_bg_color, jwidget_set_theme, jwidget_set_static_size, Widget
@section jwidget_set_bg_color
@ftable @asis
@item @t{void jwidget_set_bg_color (JWidget widget, int color);}

@end ftable
@node jwidget_set_theme, jwidget_flush_redraw, jwidget_set_bg_color, Widget
@section jwidget_set_theme
@ftable @asis
@item @t{void jwidget_set_theme (JWidget widget, JTheme theme);}

@end ftable
@node jwidget_flush_redraw, jwidget_redraw_region, jwidget_set_theme, Widget
@section jwidget_flush_redraw
@ftable @asis
@item @t{void jwidget_flush_redraw (JWidget widget);}

@end ftable
@node jwidget_redraw_region, jwidget_signal_on, jwidget_flush_redraw, Widget
@section jwidget_redraw_region
@ftable @asis
@item @t{void jwidget_redraw_region (JWidget widget, const JRegion region);}

@end ftable
@node jwidget_signal_on, jwidget_emit_signal, jwidget_redraw_region, Widget
@section jwidget_signal_on
@ftable @asis
@item @t{void jwidget_signal_on (JWidget widget);}
@end ftable
@ftable @asis
@item @t{void jwidget_signal_off (JWidget widget);}

@end ftable
@node jwidget_emit_signal, jwidget_send_message, jwidget_signal_on, Widget
@section jwidget_emit_signal
@ftable @asis
@item @t{int jwidget_emit_signal (JWidget widget, int signal_num);}

@end ftable
@node jwidget_send_message, jwidget_send_message_after_type, jwidget_emit_signal, Widget
@section jwidget_send_message
@ftable @asis
@item @t{bool jwidget_send_message (JWidget widget, JMessage msg);}

@end ftable
@node jwidget_send_message_after_type, jwidget_close_window, jwidget_send_message, Widget
@section jwidget_send_message_after_type
@ftable @asis
@item @t{bool jwidget_send_message_after_type (JWidget widget, JMessage msg, int type);}

@end ftable
@node jwidget_close_window, jwidget_capture_mouse, jwidget_send_message_after_type, Widget
@section jwidget_close_window
@ftable @asis
@item @t{void jwidget_close_window (JWidget widget);}

@end ftable
@node jwidget_capture_mouse, jwidget_release_mouse, jwidget_close_window, Widget
@section jwidget_capture_mouse
@ftable @asis
@item @t{void jwidget_capture_mouse (JWidget widget);}
@end ftable
@ftable @asis
@item @t{void jwidget_hard_capture_mouse (JWidget widget);}

@end ftable
@node jwidget_release_mouse, jwidget_find_name, jwidget_capture_mouse, Widget
@section jwidget_release_mouse
@ftable @asis
@item @t{void jwidget_release_mouse (JWidget widget);}

@end ftable
@node jwidget_find_name, jwidget_check_underscored, jwidget_release_mouse, Widget
@section jwidget_find_name
@ftable @asis
@item @t{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.

@end ftable
See also:@*
@xref{jwidget_set_name}.@*
@xref{Archivos, Archivos JID}.@*
@node jwidget_check_underscored, Widget's flags, jwidget_find_name, Widget
@section jwidget_check_underscored
@ftable @asis
@item @t{bool jwidget_check_underscored (JWidget widget, int ascii);}

@end ftable
@node Widget's flags, JM_OPEN, jwidget_check_underscored, Widget
@section Widget's flags
@ftable @asis

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

@itemize @bullet
@item 
JI_DIRTY@*
El widget está "sucio" (necesita ser redibujado en su totalidad).
@item 
JI_HIDDEN@*
El widget está escondido.
@item 
JI_SELECTED@*
El widget está seleccinado.
@item 
JI_DISABLED@*
El widget está deshabilitado.
@item 
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.
@item 
JI_HASMOUSE@*
El widget tiene el mouse (o alguno de sus hijos lo tiene).
@item 
JI_HASCAPTURE@*
El widget tiene el mouse capturado.
@item 
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.
@item 
JI_MAGNETIC@*
El widget es magnético (recibe el foco de entrada por defecto).
@item 
JI_EXPANSIVE@*
El widget es expansivo: intenta obtener el mayor lugar posible si su
padre es una caja (box).
@item 
JI_DECORATIVE@*
El widget es decorativo (ver jwidget_decorative).
@item 
JI_AUTODESTROY@*
El widget es auto-destructivo (ver jwidget_autodestroy).
@item 
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.
@end itemize



@end ftable
See also:@*
@xref{jwidget_decorative}.@*
@xref{jwidget_autodestroy}.@*
@xref{jwidget_capture_mouse, jwidget_hard_capture_mouse}.@*
@node JHook, Message, Widget, Top
@chapter JHook (gancho)


@itemize @bullet
@item 
int type;@*
@item 
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.
@item 
void *data;@*
@end itemize



@node Message, Signal, JHook, Top
@chapter 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.

@menu
* JM_OPEN::
* JM_CLOSE::
* JM_DESTROY::
* JM_DRAW::
* JM_IDLE::
* JM_SIGNAL::
* JM_REQSIZE::
* JM_SETPOS::
* JM_DRAWRGN::
* JM_DIRTYCHILDREN::
* JM_CHAR::
* JM_KEYPRESSED::
* JM_KEYRELEASED::
* JM_FOCUSENTER::
* JM_FOCUSLEAVE::
* JM_BUTTONPRESSED::
* JM_BUTTONRELEASED::
* JM_DOUBLECLICK::
* JM_MOUSEENTER::
* JM_MOUSELEAVE::
* JM_MOTION::
* JM_WHEEL::
@end menu
@node JM_OPEN, JM_CLOSE, Widget's flags, Message
@section JM_OPEN
@ftable @asis

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

@end ftable
See also:@*
@xref{JM_CLOSE}.@*
@node JM_CLOSE, JM_DESTROY, JM_OPEN, Message
@section JM_CLOSE
@ftable @asis

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

@end ftable
See also:@*
@xref{JM_OPEN}.@*
@xref{JM_DESTROY}.@*
@node JM_DESTROY, JM_DRAW, JM_CLOSE, Message
@section JM_DESTROY
@ftable @asis

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.

@end ftable
See also:@*
@xref{JM_CLOSE}.@*
@node JM_DRAW, JM_IDLE, JM_DESTROY, Message
@section JM_DRAW
@ftable @asis

@end ftable
@node JM_IDLE, JM_SIGNAL, JM_DRAW, Message
@section JM_IDLE
@ftable @asis

@end ftable
@node JM_SIGNAL, JM_REQSIZE, JM_IDLE, Message
@section JM_SIGNAL
@ftable @asis

@end ftable
@node JM_REQSIZE, JM_SETPOS, JM_SIGNAL, Message
@section JM_REQSIZE
@ftable @asis

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.

@end ftable
See also:@*
@xref{jwidget_request_size}.@*
@node JM_SETPOS, JM_DRAWRGN, JM_REQSIZE, Message
@section JM_SETPOS
@ftable @asis

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

@end ftable
See also:@*
@xref{jwidget_set_position}.@*
@node JM_DRAWRGN, JM_DIRTYCHILDREN, JM_SETPOS, Message
@section JM_DRAWRGN
@ftable @asis

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.

@end ftable
@node JM_DIRTYCHILDREN, JM_CHAR, JM_DRAWRGN, Message
@section JM_DIRTYCHILDREN
@ftable @asis

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

@end ftable
@node JM_CHAR, JM_KEYPRESSED, JM_DIRTYCHILDREN, Message
@section JM_CHAR
@ftable @asis

@end ftable
@node JM_KEYPRESSED, JM_KEYRELEASED, JM_CHAR, Message
@section JM_KEYPRESSED
@ftable @asis

@end ftable
@node JM_KEYRELEASED, JM_FOCUSENTER, JM_KEYPRESSED, Message
@section JM_KEYRELEASED
@ftable @asis

@end ftable
@node JM_FOCUSENTER, JM_FOCUSLEAVE, JM_KEYRELEASED, Message
@section JM_FOCUSENTER
@ftable @asis

@end ftable
@node JM_FOCUSLEAVE, JM_BUTTONPRESSED, JM_FOCUSENTER, Message
@section JM_FOCUSLEAVE
@ftable @asis

@end ftable
@node JM_BUTTONPRESSED, JM_BUTTONRELEASED, JM_FOCUSLEAVE, Message
@section JM_BUTTONPRESSED
@ftable @asis

@end ftable
@node JM_BUTTONRELEASED, JM_DOUBLECLICK, JM_BUTTONPRESSED, Message
@section JM_BUTTONRELEASED
@ftable @asis

@end ftable
@node JM_DOUBLECLICK, JM_MOUSEENTER, JM_BUTTONRELEASED, Message
@section JM_DOUBLECLICK
@ftable @asis

@end ftable
@node JM_MOUSEENTER, JM_MOUSELEAVE, JM_DOUBLECLICK, Message
@section JM_MOUSEENTER
@ftable @asis

@end ftable
@node JM_MOUSELEAVE, JM_MOTION, JM_MOUSEENTER, Message
@section JM_MOUSELEAVE
@ftable @asis

@end ftable
@node JM_MOTION, JM_WHEEL, JM_MOUSELEAVE, Message
@section JM_MOTION
@ftable @asis

@end ftable
@node JM_WHEEL, JI_SIGNAL_DIRTY, JM_MOTION, Message
@section JM_WHEEL
@ftable @asis



@end ftable
@node Signal, Manager, Message, Top
@chapter 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).

@menu
* JI_SIGNAL_DIRTY::
* JI_SIGNAL_ENABLE::
* JI_SIGNAL_DISABLE::
* 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::
@end menu
@node JI_SIGNAL_DIRTY, JI_SIGNAL_ENABLE, JM_WHEEL, Signal
@section JI_SIGNAL_DIRTY
@ftable @asis

Se envia cuando un widget determinado es ensuciado.

@end ftable
See also:@*
@xref{jwidget_dirty}.@*
@node JI_SIGNAL_ENABLE, JI_SIGNAL_DISABLE, JI_SIGNAL_DIRTY, Signal
@section JI_SIGNAL_ENABLE
@ftable @asis

Al cambiar el estado de un widget a activado.

@end ftable
See also:@*
@xref{jwidget_enable}.@*
@node JI_SIGNAL_DISABLE, JI_SIGNAL_SELECT, JI_SIGNAL_ENABLE, Signal
@section JI_SIGNAL_DISABLE
@ftable @asis

Al cambiar el estado de un widget a desactivado.

@end ftable
See also:@*
@xref{jwidget_enable, jwidget_disable}.@*
@node JI_SIGNAL_SELECT, JI_SIGNAL_DESELECT, JI_SIGNAL_DISABLE, Signal
@section JI_SIGNAL_SELECT
@ftable @asis

@end ftable
See also:@*
@xref{jwidget_select}.@*
@node JI_SIGNAL_DESELECT, JI_SIGNAL_SHOW, JI_SIGNAL_SELECT, Signal
@section JI_SIGNAL_DESELECT
@ftable @asis

@end ftable
See also:@*
@xref{jwidget_select, jwidget_deselect}.@*
@node JI_SIGNAL_SHOW, JI_SIGNAL_HIDE, JI_SIGNAL_DESELECT, Signal
@section JI_SIGNAL_SHOW
@ftable @asis

@end ftable
See also:@*
@xref{jwidget_show}.@*
@node JI_SIGNAL_HIDE, JI_SIGNAL_ADD_CHILD, JI_SIGNAL_SHOW, Signal
@section JI_SIGNAL_HIDE
@ftable @asis

@end ftable
See also:@*
@xref{jwidget_show, jwidget_hide}.@*
@node JI_SIGNAL_ADD_CHILD, JI_SIGNAL_REMOVE_CHILD, JI_SIGNAL_HIDE, Signal
@section JI_SIGNAL_ADD_CHILD
@ftable @asis

@end ftable
See also:@*
@xref{jwidget_add_child}.@*
@node JI_SIGNAL_REMOVE_CHILD, JI_SIGNAL_NEW_PARENT, JI_SIGNAL_ADD_CHILD, Signal
@section JI_SIGNAL_REMOVE_CHILD
@ftable @asis

@end ftable
See also:@*
@xref{jwidget_remove_child}.@*
@node JI_SIGNAL_NEW_PARENT, JI_SIGNAL_GET_TEXT, JI_SIGNAL_REMOVE_CHILD, Signal
@section JI_SIGNAL_NEW_PARENT
@ftable @asis

@end ftable
See also:@*
@xref{jwidget_add_child}.@*
@xref{jwidget_remove_child}.@*
@node JI_SIGNAL_GET_TEXT, JI_SIGNAL_SET_TEXT, JI_SIGNAL_NEW_PARENT, Signal
@section JI_SIGNAL_GET_TEXT
@ftable @asis

@end ftable
See also:@*
@xref{JI_SIGNAL_SET_TEXT}.@*
@node JI_SIGNAL_SET_TEXT, JI_SIGNAL_INIT_THEME, JI_SIGNAL_GET_TEXT, Signal
@section JI_SIGNAL_SET_TEXT
@ftable @asis

@end ftable
See also:@*
@xref{JI_SIGNAL_GET_TEXT}.@*
@node JI_SIGNAL_INIT_THEME, JI_SIGNAL_CHECK_CHANGE, JI_SIGNAL_SET_TEXT, Signal
@section JI_SIGNAL_INIT_THEME
@ftable @asis

@end ftable
See also:@*
@xref{jwidget_init_theme}.@*
@node JI_SIGNAL_CHECK_CHANGE, JI_SIGNAL_RADIO_CHANGE, JI_SIGNAL_INIT_THEME, Signal
@section JI_SIGNAL_CHECK_CHANGE
@ftable @asis

@end ftable
@node JI_SIGNAL_RADIO_CHANGE, JI_SIGNAL_ENTRY_CHANGE, JI_SIGNAL_CHECK_CHANGE, Signal
@section JI_SIGNAL_RADIO_CHANGE
@ftable @asis

@end ftable
@node JI_SIGNAL_ENTRY_CHANGE, JI_SIGNAL_LISTBOX_CHANGE, JI_SIGNAL_RADIO_CHANGE, Signal
@section JI_SIGNAL_ENTRY_CHANGE
@ftable @asis

@end ftable
@node JI_SIGNAL_LISTBOX_CHANGE, JI_SIGNAL_LISTBOX_SELECT, JI_SIGNAL_ENTRY_CHANGE, Signal
@section JI_SIGNAL_LISTBOX_CHANGE
@ftable @asis

@end ftable
@node JI_SIGNAL_LISTBOX_SELECT, JI_SIGNAL_MENUITEM_SELECT, JI_SIGNAL_LISTBOX_CHANGE, Signal
@section JI_SIGNAL_LISTBOX_SELECT
@ftable @asis

@end ftable
@node JI_SIGNAL_MENUITEM_SELECT, JI_SIGNAL_SLIDER_CHANGE, JI_SIGNAL_LISTBOX_SELECT, Signal
@section JI_SIGNAL_MENUITEM_SELECT
@ftable @asis

@end ftable
@node JI_SIGNAL_SLIDER_CHANGE, ji_get_default_manager, JI_SIGNAL_MENUITEM_SELECT, Signal
@section JI_SIGNAL_SLIDER_CHANGE
@ftable @asis



@end ftable
@node Manager, Window, Signal, Top
@chapter Manager (gestor)

@menu
* ji_get_default_manager::
* jmanager_new::
* jmanager_free::
* jmanager_run::
* jmanager_poll::
* jmanager_send_message::
* jmanager_get_focus::
* jmanager_get_mouse::
* jmanager_get_capture::
* jmanager_set_focus::
* jmanager_set_mouse::
* jmanager_set_capture::
* jmanager_attract_focus::
* jmanager_free_focus::
* jmanager_free_widget::
* jmanager_remove_message::
* jmanager_remove_messages_for::
* jmanager_refresh_screen::
* jmanager_dispatch_messages::
* jmanager_dispatch_draw_messages::
* jmanager_open_window::
* jmanager_close_window::
* JI_SIGNAL_MANAGER_EXTERNAL_CLOSE::
* JI_SIGNAL_MANAGER_ADD_WINDOW::
* JI_SIGNAL_MANAGER_REMOVE_WINDOW::
* JI_SIGNAL_MANAGER_IDLE::
* JI_SIGNAL_MANAGER_LOSTCHAR::
@end menu
@node ji_get_default_manager, jmanager_new, JI_SIGNAL_SLIDER_CHANGE, Manager
@section ji_get_default_manager
@ftable @asis
@item @t{JWidget ji_get_default_manager (void);}
Retorna un puntero del manager principal, el primer manager creado
con jmanager_new.

@end ftable
See also:@*
@xref{jmanager_new}.@*
@node jmanager_new, jmanager_free, ji_get_default_manager, Manager
@section jmanager_new
@ftable @asis
@item @t{JWidget jmanager_new (void);}

@end ftable
See also:@*
@xref{jmanager_free}.@*
@node jmanager_free, jmanager_run, jmanager_new, Manager
@section jmanager_free
@ftable @asis
@item @t{void jmanager_free (JWidget manager);}

@end ftable
See also:@*
@xref{jmanager_new}.@*
@node jmanager_run, jmanager_poll, jmanager_free, Manager
@section jmanager_run
@ftable @asis
@item @t{void jmanager_run (JWidget manager);}

@end ftable
See also:@*
@xref{jmanager_poll}.@*
@node jmanager_poll, jmanager_send_message, jmanager_run, Manager
@section jmanager_poll
@ftable @asis
@item @t{bool jmanager_poll (JWidget manager, bool all_windows);}

@end ftable
See also:@*
@xref{jmanager_run}.@*
@node jmanager_send_message, jmanager_get_focus, jmanager_poll, Manager
@section jmanager_send_message
@ftable @asis
@item @t{void jmanager_send_message (const JMessage msg);}

@end ftable
See also:@*
@xref{jmanager_dispatch_messages}.@*
@node jmanager_get_focus, jmanager_get_mouse, jmanager_send_message, Manager
@section jmanager_get_focus
@ftable @asis
@item @t{JWidget jmanager_get_focus (void);}

@end ftable
See also:@*
@xref{jmanager_set_focus}.@*
@node jmanager_get_mouse, jmanager_get_capture, jmanager_get_focus, Manager
@section jmanager_get_mouse
@ftable @asis
@item @t{JWidget jmanager_get_mouse (void);}

@end ftable
See also:@*
@xref{jmanager_set_mouse}.@*
@node jmanager_get_capture, jmanager_set_focus, jmanager_get_mouse, Manager
@section jmanager_get_capture
@ftable @asis
@item @t{JWidget jmanager_get_capture (void);}

@end ftable
See also:@*
@xref{jmanager_set_capture}.@*
@node jmanager_set_focus, jmanager_set_mouse, jmanager_get_capture, Manager
@section jmanager_set_focus
@ftable @asis
@item @t{void jmanager_set_focus (JWidget widget);}

@end ftable
See also:@*
@xref{jmanager_get_focus}.@*
@node jmanager_set_mouse, jmanager_set_capture, jmanager_set_focus, Manager
@section jmanager_set_mouse
@ftable @asis
@item @t{void jmanager_set_mouse (JWidget widget);}

@end ftable
See also:@*
@xref{jmanager_get_mouse}.@*
@node jmanager_set_capture, jmanager_attract_focus, jmanager_set_mouse, Manager
@section jmanager_set_capture
@ftable @asis
@item @t{void jmanager_set_capture (JWidget widget);}

@end ftable
See also:@*
@xref{jmanager_get_capture}.@*
@node jmanager_attract_focus, jmanager_free_focus, jmanager_set_capture, Manager
@section jmanager_attract_focus
@ftable @asis
@item @t{void jmanager_attract_focus (JWidget widget);}

@end ftable
See also:@*
@xref{jwidget_magnetic}.@*
@node jmanager_free_focus, jmanager_free_widget, jmanager_attract_focus, Manager
@section jmanager_free_focus
@ftable @asis
@item @t{void jmanager_free_focus (void);}
@end ftable
@ftable @asis
@item @t{void jmanager_free_mouse (void);}
@end ftable
@ftable @asis
@item @t{void jmanager_free_capture (void);}

@end ftable
See also:@*
@xref{jmanager_set_focus}.@*
@xref{ji_manager_set_mouse}.@*
@xref{ji_manager_set_capture}.@*
@node jmanager_free_widget, jmanager_remove_message, jmanager_free_focus, Manager
@section jmanager_free_widget
@ftable @asis
@item @t{void jmanager_free_widget (JWidget widget);}

@end ftable
@node jmanager_remove_message, jmanager_remove_messages_for, jmanager_free_widget, Manager
@section jmanager_remove_message
@ftable @asis
@item @t{void jmanager_remove_message (JMessage msg);}

@end ftable
@node jmanager_remove_messages_for, jmanager_refresh_screen, jmanager_remove_message, Manager
@section jmanager_remove_messages_for
@ftable @asis
@item @t{void jmanager_remove_messages_for (JWidget widget);}

@end ftable
@node jmanager_refresh_screen, jmanager_dispatch_messages, jmanager_remove_messages_for, Manager
@section jmanager_refresh_screen
@ftable @asis
@item @t{void jmanager_refresh_screen (void);}

@end ftable
@node jmanager_dispatch_messages, jmanager_dispatch_draw_messages, jmanager_refresh_screen, Manager
@section jmanager_dispatch_messages
@ftable @asis
@item @t{void jmanager_dispatch_messages (void);}

@end ftable
@node jmanager_dispatch_draw_messages, jmanager_open_window, jmanager_dispatch_messages, Manager
@section jmanager_dispatch_draw_messages
@ftable @asis
@item @t{void jmanager_dispatch_draw_messages (void);}

@end ftable
@node jmanager_open_window, jmanager_close_window, jmanager_dispatch_draw_messages, Manager
@section jmanager_open_window
@ftable @asis
@item @t{void jmanager_open_window (JWidget manager, JWidget window);}

@end ftable
@node jmanager_close_window, JI_SIGNAL_MANAGER_EXTERNAL_CLOSE, jmanager_open_window, Manager
@section jmanager_close_window
@ftable @asis
@item @t{void jmanager_close_window (JWidget manager, JWidget window, bool sendtokill);}

@end ftable
@node JI_SIGNAL_MANAGER_EXTERNAL_CLOSE, JI_SIGNAL_MANAGER_ADD_WINDOW, jmanager_close_window, Manager
@section JI_SIGNAL_MANAGER_EXTERNAL_CLOSE
@ftable @asis

@end ftable
@node JI_SIGNAL_MANAGER_ADD_WINDOW, JI_SIGNAL_MANAGER_REMOVE_WINDOW, JI_SIGNAL_MANAGER_EXTERNAL_CLOSE, Manager
@section JI_SIGNAL_MANAGER_ADD_WINDOW
@ftable @asis

@end ftable
@node JI_SIGNAL_MANAGER_REMOVE_WINDOW, JI_SIGNAL_MANAGER_IDLE, JI_SIGNAL_MANAGER_ADD_WINDOW, Manager
@section JI_SIGNAL_MANAGER_REMOVE_WINDOW
@ftable @asis

@end ftable
@node JI_SIGNAL_MANAGER_IDLE, JI_SIGNAL_MANAGER_LOSTCHAR, JI_SIGNAL_MANAGER_REMOVE_WINDOW, Manager
@section JI_SIGNAL_MANAGER_IDLE
@ftable @asis

@end ftable
@node JI_SIGNAL_MANAGER_LOSTCHAR, jwindow_new, JI_SIGNAL_MANAGER_IDLE, Manager
@section JI_SIGNAL_MANAGER_LOSTCHAR
@ftable @asis



@end ftable
@node Window, Box, Manager, Top
@chapter 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.

@menu
* jwindow_new::
* jwindow_new_desktop::
* jwindow_get_killer::
* jwindow_get_manager::
* jwindow_mobile::
* jwindow_remap::
* jwindow_center::
* jwindow_position::
* jwindow_open::
* jwindow_open_fg::
* jwindow_open_bg::
* jwindow_close::
* jwindow_is_toplevel::
* jwindow_is_foreground::
* jwindow_is_desktop::
* JI_SIGNAL_WINDOW_CLOSE::
* JI_SIGNAL_WINDOW_RESIZE::
@end menu
@node jwindow_new, jwindow_new_desktop, JI_SIGNAL_MANAGER_LOSTCHAR, Window
@section jwindow_new
@ftable @asis
@item @t{JWidget jwindow_new (const char *text);}
Crea una nueva ventana con el texto "text" en la barra de título.

@end ftable
@node jwindow_new_desktop, jwindow_get_killer, jwindow_new, Window
@section jwindow_new_desktop
@ftable @asis
@item @t{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).

@end ftable
See also:@*
@xref{jwindow_is_desktop}.@*
@node jwindow_get_killer, jwindow_get_manager, jwindow_new_desktop, Window
@section jwindow_get_killer
@ftable @asis
@item @t{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 ).

@end ftable
See also:@*
@xref{jwindow_close}.@*
@node jwindow_get_manager, jwindow_mobile, jwindow_get_killer, Window
@section jwindow_get_manager
@ftable @asis
@item @t{JWidget jwindow_get_manager (JWidget window);}
Devuelve el manager en el cual la ventana "window" se encuentra
dentro.

@end ftable
See also:@*
@xref{jwindow_open}.@*
@xref{jmanager_open_window}.@*
@node jwindow_mobile, jwindow_remap, jwindow_get_manager, Window
@section jwindow_mobile
@ftable @asis
@item @t{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.

@end ftable
@node jwindow_remap, jwindow_center, jwindow_mobile, Window
@section jwindow_remap
@ftable @asis
@item @t{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.

@end ftable
@node jwindow_center, jwindow_position, jwindow_remap, Window
@section jwindow_center
@ftable @asis
@item @t{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).

@end ftable
See also:@*
@xref{jwindow_position}.@*
@node jwindow_position, jwindow_open, jwindow_center, Window
@section jwindow_position
@ftable @asis
@item @t{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.

@end ftable
@node jwindow_open, jwindow_open_fg, jwindow_position, Window
@section jwindow_open
@ftable @asis
@item @t{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).

@end ftable
See also:@*
@xref{jwindow_open_fg}.@*
@xref{jwindow_open_bg}.@*
@xref{ji_get_default_manager}.@*
@xref{jmanager_poll}.@*
@node jwindow_open_fg, jwindow_open_bg, jwindow_open, Window
@section jwindow_open_fg
@ftable @asis
@item @t{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:
@example

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

@end ftable
See also:@*
@xref{jwindow_open_bg}.@*
@xref{jwindow_get_killer}.@*
@xref{jwidget_free}.@*
@node jwindow_open_bg, jwindow_close, jwindow_open_fg, Window
@section jwindow_open_bg
@ftable @asis
@item @t{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.

@end ftable
See also:@*
@xref{jwindow_open}.@*
@xref{jwindow_open_fg}.@*
@xref{jwidget_free}.@*
@xref{jwidget_autodestroy}.@*
@node jwindow_close, jwindow_is_toplevel, jwindow_open_bg, Window
@section jwindow_close
@ftable @asis
@item @t{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).

@end ftable
See also:@*
@xref{jwindow_open}.@*
@xref{jwindow_get_killer}.@*
@node jwindow_is_toplevel, jwindow_is_foreground, jwindow_close, Window
@section jwindow_is_toplevel
@ftable @asis
@item @t{bool jwindow_is_toplevel (JWidget window);}
Retorna TRUE si la ventana "window" se encuentra encima de todas las
ventanas.

@end ftable
@node jwindow_is_foreground, jwindow_is_desktop, jwindow_is_toplevel, Window
@section jwindow_is_foreground
@ftable @asis
@item @t{bool jwindow_is_foreground (JWidget window);}
Retorna TRUE si la ventana se ejecuta en primer plano (foreground).

@end ftable
See also:@*
@xref{jwindow_open_fg}.@*
@node jwindow_is_desktop, JI_SIGNAL_WINDOW_CLOSE, jwindow_is_foreground, Window
@section jwindow_is_desktop
@ftable @asis
@item @t{bool jwindow_is_desktop (JWidget window);}
Retorna TRUE si la ventana es de tipo escritorio (desktop).

@end ftable
See also:@*
@xref{jwindow_new_desktop}.@*
@node JI_SIGNAL_WINDOW_CLOSE, JI_SIGNAL_WINDOW_RESIZE, jwindow_is_desktop, Window
@section JI_SIGNAL_WINDOW_CLOSE
@ftable @asis

@end ftable
@node JI_SIGNAL_WINDOW_RESIZE, jbox_new, JI_SIGNAL_WINDOW_CLOSE, Window
@section JI_SIGNAL_WINDOW_RESIZE
@ftable @asis


@end ftable
@node Box, Label, Window, Top
@chapter 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.

@menu
* jbox_new::
@end menu
@node jbox_new, jlabel_new, JI_SIGNAL_WINDOW_RESIZE, Box
@section jbox_new
@ftable @asis
@item @t{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:

@itemize @bullet
@item 
JI_HORIZONTAL o JI_VERTICAL:@*
Indica si queremos ordenar los widgets de forma horizontal o
vertical respectivamente.
@end itemize

Y puede o no estar en combinación con:

@itemize @bullet
@item 
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).
@end itemize




@end ftable
@node Label, Button, Box, Top
@chapter Label (etiqueta)

@menu
* jlabel_new::
@end menu
@node jlabel_new, jbutton_new, jbox_new, Label
@section jlabel_new
@ftable @asis
@item @t{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.



@end ftable
@node Button, Check, Label, Top
@chapter 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:

@itemize @bullet
@item 
Primero se envía la señal JI_SIGNAL_BUTTON_SELECT@*
@item 
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.
@end itemize

@menu
* jbutton_new::
* jbutton_set_icon::
* jbutton_set_icon_align::
* jbutton_set_bevel::
* jbutton_get_bevel::
* jbutton_add_command::
* jbutton_add_command_data::
* JI_SIGNAL_BUTTON_SELECT::
@end menu
@node jbutton_new, jbutton_set_icon, jlabel_new, Button
@section jbutton_new
@ftable @asis
@item @t{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.

@end ftable
See also:@*
@xref{jbutton_add_command}.@*
@xref{jwindow_get_killer}.@*
@node jbutton_set_icon, jbutton_set_icon_align, jbutton_new, Button
@section jbutton_set_icon
@ftable @asis
@item @t{void jbutton_set_icon (JWidget button, struct BITMAP *icon);}

@end ftable
@node jbutton_set_icon_align, jbutton_set_bevel, jbutton_set_icon, Button
@section jbutton_set_icon_align
@ftable @asis
@item @t{void jbutton_set_icon_align (JWidget button, int icon_align);}

@end ftable
@node jbutton_set_bevel, jbutton_get_bevel, jbutton_set_icon_align, Button
@section jbutton_set_bevel
@ftable @asis
@item @t{void jbutton_set_bevel (JWidget button, int b0, int b1, int b2, int b3);}

@end ftable
@node jbutton_get_bevel, jbutton_add_command, jbutton_set_bevel, Button
@section jbutton_get_bevel
@ftable @asis
@item @t{void jbutton_get_bevel (JWidget button, int *b4);}

@end ftable
@node jbutton_add_command, jbutton_add_command_data, jbutton_get_bevel, Button
@section jbutton_add_command
@ftable @asis
@item @t{void jbutton_add_command (JWidget button, void (*command) (JWidget button));}

@end ftable
See also:@*
@xref{jbutton_add_command_data}.@*
@xref{JI_SIGNAL_BUTTON_SELECT}.@*
@node jbutton_add_command_data, JI_SIGNAL_BUTTON_SELECT, jbutton_add_command, Button
@section jbutton_add_command_data
@ftable @asis
@item @t{void jbutton_add_command_data (JWidget button, void (*command) (JWidget button, void *data), void *data);}

@end ftable
See also:@*
@xref{jbutton_add_command}.@*
@xref{JI_SIGNAL_BUTTON_SELECT}.@*
@node JI_SIGNAL_BUTTON_SELECT, jcheck_new, jbutton_add_command_data, Button
@section JI_SIGNAL_BUTTON_SELECT
@ftable @asis

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.



@end ftable
See also:@*
@xref{Button, Button (botón)}.@*
@xref{jwidget_add_hook}.@*
@node Check, Theme, Button, Top
@chapter Check (caja de comprobación)

@menu
* jcheck_new::
* jcheck_set_icon_align::
@end menu
@node jcheck_new, jcheck_set_icon_align, JI_SIGNAL_BUTTON_SELECT, Check
@section jcheck_new
@ftable @asis
@item @t{JWidget jcheck_new (const char *text);}
Crea una nueva caja de comprobación. Sirven para representar
opciones booleanas (valores verdadero o falso).

@end ftable
@node jcheck_set_icon_align, ji_load_widget, jcheck_new, Check
@section jcheck_set_icon_align
@ftable @asis
@item @t{void jcheck_set_icon_align (JWidget check, int icon_align);}



@end ftable
@node Theme, Archivos, Check, Top
@chapter Theme (tema)



@node Archivos, Font, Theme, Top
@chapter Archivos JID

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

Ejemplo:

En "archivo.jid":
@example

<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>
@end example

En un "archivo.c":
@example

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


@menu
* ji_load_widget::
@end menu
@node ji_load_widget, ji_font_load, jcheck_set_icon_align, Archivos
@section ji_load_widget
@ftable @asis
@item @t{JWidget ji_load_widget (const char *filename, const char *name);}



@end ftable
@node Font, JList, Archivos, Top
@chapter Font (fuente)

@menu
* ji_font_load::
* ji_font_get_size::
* ji_font_set_size::
* ji_font_get_aa_mode::
* ji_font_set_aa_mode::
* ji_font_is_fixed::
* ji_font_get_available_fixed_sizes::
* ji_font_get_char_extra_spacing::
* ji_font_set_char_extra_spacing::
* ji_font_char_len::
* ji_font_text_len::
@end menu
@node ji_font_load, ji_font_get_size, ji_load_widget, Font
@section ji_font_load
@ftable @asis
@item @t{FONT *ji_font_load (const char *filepathname);}

@end ftable
@node ji_font_get_size, ji_font_set_size, ji_font_load, Font
@section ji_font_get_size
@ftable @asis
@item @t{int ji_font_get_size (FONT *f);}

@end ftable
@node ji_font_set_size, ji_font_get_aa_mode, ji_font_get_size, Font
@section ji_font_set_size
@ftable @asis
@item @t{int ji_font_set_size (FONT *f, int height);}

@end ftable
@node ji_font_get_aa_mode, ji_font_set_aa_mode, ji_font_set_size, Font
@section ji_font_get_aa_mode
@ftable @asis
@item @t{int ji_font_get_aa_mode (FONT *f);}

@end ftable
@node ji_font_set_aa_mode, ji_font_is_fixed, ji_font_get_aa_mode, Font
@section ji_font_set_aa_mode
@ftable @asis
@item @t{int ji_font_set_aa_mode (FONT *f, int mode);}

@end ftable
@node ji_font_is_fixed, ji_font_get_available_fixed_sizes, ji_font_set_aa_mode, Font
@section ji_font_is_fixed
@ftable @asis
@item @t{bool ji_font_is_fixed (FONT *f);}
@end ftable
@ftable @asis
@item @t{bool ji_font_is_scalable (FONT *f);}

@end ftable
@node ji_font_get_available_fixed_sizes, ji_font_get_char_extra_spacing, ji_font_is_fixed, Font
@section ji_font_get_available_fixed_sizes
@ftable @asis
@item @t{const int *ji_font_get_available_fixed_sizes (FONT *f, int *n);}

@end ftable
@node ji_font_get_char_extra_spacing, ji_font_set_char_extra_spacing, ji_font_get_available_fixed_sizes, Font
@section ji_font_get_char_extra_spacing
@ftable @asis
@item @t{int ji_font_get_char_extra_spacing (FONT *f);}

@end ftable
@node ji_font_set_char_extra_spacing, ji_font_char_len, ji_font_get_char_extra_spacing, Font
@section ji_font_set_char_extra_spacing
@ftable @asis
@item @t{void ji_font_set_char_extra_spacing (FONT *f, int spacing);}

@end ftable
@node ji_font_char_len, ji_font_text_len, ji_font_set_char_extra_spacing, Font
@section ji_font_char_len
@ftable @asis
@item @t{int ji_font_char_len (FONT *f, int chr);}
Retorna la longitud (ancho) de un caracter en pixeles.

@end ftable
@node ji_font_text_len, jlist_alloc, ji_font_char_len, Font
@section ji_font_text_len
@ftable @asis
@item @t{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".



@end ftable
@node JList, JRect, Font, Top
@chapter JList - Listas Enlazadas

Las listas enlazadas se manejan a través de los punteros JList:
@example

typedef struct jlist *JList;
@end example

La estructura jlist se define:
@example

struct jlist
@{
  void *data;
  JList next;
  JList prev;
@};
@end example

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:
@example

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

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

@menu
* jlist_alloc::
* jlist_free::
* jlist_free_1::
* jlist_append::
* jlist_prepend::
* jlist_insert::
* jlist_insert_sorted::
* jlist_insert_before::
* jlist_concat::
* jlist_remove::
* jlist_remove_all::
* jlist_remove_link::
* jlist_delete_link::
* jlist_reverse::
* jlist_copy::
* jlist_nth::
* jlist_nth_prev::
* jlist_find::
* jlist_find_custom::
* jlist_position::
* jlist_index::
* jlist_last::
* jlist_first::
* jlist_length::
* jlist_foreach::
* jlist_sort::
* jlist_sort_with_data::
* jlist_nth_data::
* jlist_previous::
@end menu
@node jlist_alloc, jlist_free, ji_font_text_len, JList
@section jlist_alloc
@ftable @asis
@item @t{JList jlist_alloc (void);}

@end ftable
@node jlist_free, jlist_free_1, jlist_alloc, JList
@section jlist_free
@ftable @asis
@item @t{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).

@end ftable
See also:@*
@xref{jlist_free_1}.@*
@node jlist_free_1, jlist_append, jlist_free, JList
@section jlist_free_1
@ftable @asis
@item @t{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.

@end ftable
See also:@*
@xref{jlist_free}.@*
@xref{ji_list_alloc}.@*
@node jlist_append, jlist_prepend, jlist_free_1, JList
@section jlist_append
@ftable @asis
@item @t{JList jlist_append (JList list, void *data);}
Agrega un nuevo elemento con los datos "data" al final de la lista.

@end ftable
@node jlist_prepend, jlist_insert, jlist_append, JList
@section jlist_prepend
@ftable @asis
@item @t{JList jlist_prepend (JList list, void *data);}
Agrega un nuevo elemento con los datos "data" al comienzo de la lista.

@end ftable
@node jlist_insert, jlist_insert_sorted, jlist_prepend, JList
@section jlist_insert
@ftable @asis
@item @t{JList jlist_insert (JList list, void *data, int position);}

@end ftable
@node jlist_insert_sorted, jlist_insert_before, jlist_insert, JList
@section jlist_insert_sorted
@ftable @asis
@item @t{JList jlist_insert_sorted (JList list, void *data, JCompareFunc func);}

@end ftable
@node jlist_insert_before, jlist_concat, jlist_insert_sorted, JList
@section jlist_insert_before
@ftable @asis
@item @t{JList jlist_insert_before (JList list, JList sibling, void *data);}

@end ftable
@node jlist_concat, jlist_remove, jlist_insert_before, JList
@section jlist_concat
@ftable @asis
@item @t{JList jlist_concat (JList list1, JList list2);}

@end ftable
@node jlist_remove, jlist_remove_all, jlist_concat, JList
@section jlist_remove
@ftable @asis
@item @t{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.

@end ftable
@node jlist_remove_all, jlist_remove_link, jlist_remove, JList
@section jlist_remove_all
@ftable @asis
@item @t{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.

@end ftable
@node jlist_remove_link, jlist_delete_link, jlist_remove_all, JList
@section jlist_remove_link
@ftable @asis
@item @t{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).

@end ftable
See also:@*
@xref{jlist_delete_link}.@*
@xref{ji_list_free_1}.@*
@node jlist_delete_link, jlist_reverse, jlist_remove_link, JList
@section jlist_delete_link
@ftable @asis
@item @t{JList jlist_delete_link (JList list, JList link);}
Remueve el nodo "link" de la lista "list". El nodo será eliminado,
los datos no.

@end ftable
See also:@*
@xref{jlist_remove_link}.@*
@node jlist_reverse, jlist_copy, jlist_delete_link, JList
@section jlist_reverse
@ftable @asis
@item @t{JList jlist_reverse (JList list);}

@end ftable
@node jlist_copy, jlist_nth, jlist_reverse, JList
@section jlist_copy
@ftable @asis
@item @t{JList jlist_copy (JList list);}
Copia la lista generando una completamente nueva con cada elemento
apuntado a los mismos datos que la anterior lista.

@end ftable
@node jlist_nth, jlist_nth_prev, jlist_copy, JList
@section jlist_nth
@ftable @asis
@item @t{JList jlist_nth (JList list, unsigned int n);}

@end ftable
@node jlist_nth_prev, jlist_find, jlist_nth, JList
@section jlist_nth_prev
@ftable @asis
@item @t{JList jlist_nth_prev (JList list, unsigned int n);}

@end ftable
@node jlist_find, jlist_find_custom, jlist_nth_prev, JList
@section jlist_find
@ftable @asis
@item @t{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.

@end ftable
@node jlist_find_custom, jlist_position, jlist_find, JList
@section jlist_find_custom
@ftable @asis
@item @t{JList jlist_find_custom (JList list, const void *data, JCompareFunc func);}

@end ftable
@node jlist_position, jlist_index, jlist_find_custom, JList
@section jlist_position
@ftable @asis
@item @t{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ó.

@end ftable
See also:@*
@xref{jlist_index}.@*
@node jlist_index, jlist_last, jlist_position, JList
@section jlist_index
@ftable @asis
@item @t{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ó.

@end ftable
See also:@*
@xref{jlist_position}.@*
@node jlist_last, jlist_first, jlist_index, JList
@section jlist_last
@ftable @asis
@item @t{JList jlist_last (JList list);}
Retorna un puntero al último elemento de la lista (puede devolver
NULL si list es NULL).

@end ftable
@node jlist_first, jlist_length, jlist_last, JList
@section jlist_first
@ftable @asis
@item @t{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).

@end ftable
@node jlist_length, jlist_foreach, jlist_first, JList
@section jlist_length
@ftable @asis
@item @t{unsigned int jlist_length (JList list);}
Retorna la cantidad de nodos que contiene la lista "list".

@end ftable
@node jlist_foreach, jlist_sort, jlist_length, JList
@section jlist_foreach
@ftable @asis
@item @t{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:
@example

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);
@end example

Imprime:
@example

1
2
3
@end example

@end ftable
@node jlist_sort, jlist_sort_with_data, jlist_foreach, JList
@section jlist_sort
@ftable @asis
@item @t{JList jlist_sort (JList list, JCompareFunc compare_func);}

@end ftable
@node jlist_sort_with_data, jlist_nth_data, jlist_sort, JList
@section jlist_sort_with_data
@ftable @asis
@item @t{JList jlist_sort_with_data (JList list, JCompareDataFunc compare_func, void *user_data);}

@end ftable
@node jlist_nth_data, jlist_previous, jlist_sort_with_data, JList
@section jlist_nth_data
@ftable @asis
@item @t{void *jlist_nth_data (JList list, unsigned int n);}

@end ftable
@node jlist_previous, jrect_new, jlist_nth_data, JList
@section jlist_previous
@ftable @asis
@item @t{#define jlist_previous(list)}
@end ftable
@ftable @asis
@item @t{#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.



@end ftable
@node JRect, JRegion, JList, Top
@chapter JRect - Rectángulos

@example

struct jrect
@{
  int x, y, w, h;
@};
@end example

@menu
* jrect_new::
* jrect_new_copy::
* jrect_free::
* jrect_copy::
* jrect_replace::
* jrect_add::
* jrect_intersect::
* jrect_shrink::
* jrect_stretch::
* jrect_has_intersection::
@end menu
@node jrect_new, jrect_new_copy, jlist_previous, JRect
@section jrect_new
@ftable @asis
@item @t{JRect jrect_new (int x, int y, int w, int h);}

@end ftable
See also:@*
@xref{jrect_free}.@*
@node jrect_new_copy, jrect_free, jrect_new, JRect
@section jrect_new_copy
@ftable @asis
@item @t{JRect jrect_new_copy (const JRect rect);}

@end ftable
See also:@*
@xref{jrect_new}.@*
@xref{jrect_copy}.@*
@node jrect_free, jrect_copy, jrect_new_copy, JRect
@section jrect_free
@ftable @asis
@item @t{void jrect_free (JRect rect);}

@end ftable
See also:@*
@xref{jrect_new}.@*
@node jrect_copy, jrect_replace, jrect_free, JRect
@section jrect_copy
@ftable @asis
@item @t{void jrect_copy (JRect dst, const JRect src);}

@end ftable
See also:@*
@xref{jrect_new_copy}.@*
@node jrect_replace, jrect_add, jrect_copy, JRect
@section jrect_replace
@ftable @asis
@item @t{void jrect_replace (JRect rect, int x, int y, int w, int h);}

@end ftable
@node jrect_add, jrect_intersect, jrect_replace, JRect
@section jrect_add
@ftable @asis
@item @t{void jrect_add (JRect rect, const JRect other);}

@end ftable
@node jrect_intersect, jrect_shrink, jrect_add, JRect
@section jrect_intersect
@ftable @asis
@item @t{bool jrect_intersect (JRect rect, const JRect other);}

@end ftable
See also:@*
@xref{jrect_has_intersection}.@*
@node jrect_shrink, jrect_stretch, jrect_intersect, JRect
@section jrect_shrink
@ftable @asis
@item @t{void jrect_shrink (JRect rect, int border);}

@end ftable
See also:@*
@xref{jrect_stretch}.@*
@node jrect_stretch, jrect_has_intersection, jrect_shrink, JRect
@section jrect_stretch
@ftable @asis
@item @t{void jrect_stretch (JRect rect, int border);}

@end ftable
See also:@*
@xref{jrect_shrink}.@*
@node jrect_has_intersection, jregion_new, jrect_stretch, JRect
@section jrect_has_intersection
@ftable @asis
@item @t{#define jrect_has_intersection(rect, other)}



@end ftable
See also:@*
@xref{jrect_intersect}.@*
@node JRegion, Funciones, JRect, Top
@chapter JRegion - Regiones

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

typedef struct jregion JRegion;

struct jregion
@{
  JList rects;
@};
@end example

@menu
* jregion_new::
* jregion_new_copy::
* jregion_free::
* jregion_clear::
* jregion_move::
* jregion_join::
* jregion_add::
* jregion_subtract::
* jregion_intersect::
* jregion_add2::
* jregion_subtract2::
* jregion_intersect2::
@end menu
@node jregion_new, jregion_new_copy, jrect_has_intersection, JRegion
@section jregion_new
@ftable @asis
@item @t{JRegion jregion_new (void);}
Crea una nueva región vacía. Usted deberá eliminar la región
devuelta mediante jregion_free.

@end ftable
See also:@*
@xref{jregion_free}.@*
@node jregion_new_copy, jregion_free, jregion_new, JRegion
@section jregion_new_copy
@ftable @asis
@item @t{JRegion jregion_new_copy (const JRegion region);}
Crea una nueva copia de region. Usted deberá eliminar la región
devuelta mediante jregion_free.

@end ftable
See also:@*
@xref{jregion_new}.@*
@node jregion_free, jregion_clear, jregion_new_copy, JRegion
@section jregion_free
@ftable @asis
@item @t{void jregion_free (JRegion region);}

@end ftable
See also:@*
@xref{jregion_new}.@*
@xref{ji_region_clear}.@*
@node jregion_clear, jregion_move, jregion_free, JRegion
@section jregion_clear
@ftable @asis
@item @t{void jregion_clear (JRegion region);}

@end ftable
See also:@*
@xref{jregion_free}.@*
@node jregion_move, jregion_join, jregion_clear, JRegion
@section jregion_move
@ftable @asis
@item @t{void jregion_move (JRegion region, int x, int y);}

@end ftable
@node jregion_join, jregion_add, jregion_move, JRegion
@section jregion_join
@ftable @asis
@item @t{void jregion_join (JRegion region, JRegion other);}

@end ftable
@node jregion_add, jregion_subtract, jregion_join, JRegion
@section jregion_add
@ftable @asis
@item @t{void jregion_add (JRegion region, const JRect rect);}

@end ftable
@node jregion_subtract, jregion_intersect, jregion_add, JRegion
@section jregion_subtract
@ftable @asis
@item @t{void jregion_subtract (JRegion region, const JRect rect);}

@end ftable
@node jregion_intersect, jregion_add2, jregion_subtract, JRegion
@section jregion_intersect
@ftable @asis
@item @t{void jregion_intersect (JRegion region, const JRect rect);}

@end ftable
@node jregion_add2, jregion_subtract2, jregion_intersect, JRegion
@section jregion_add2
@ftable @asis
@item @t{void jregion_add2 (JRegion region, const JRegion other);}

@end ftable
@node jregion_subtract2, jregion_intersect2, jregion_add2, JRegion
@section jregion_subtract2
@ftable @asis
@item @t{void jregion_subtract2 (JRegion region, const JRegion other);}

@end ftable
@node jregion_intersect2, _ji_get_widget_by_id, jregion_subtract2, JRegion
@section jregion_intersect2
@ftable @asis
@item @t{void jregion_intersect2 (JRegion region, const JRegion other);}



@end ftable
@node Funciones, Actualizaciones, JRegion, Top
@chapter Funciones Internas

@menu
* _ji_get_widget_by_id::
* _ji_get_widget_array::
* _ji_get_new_widget::
* _ji_free_widget::
* _ji_free_all_widgets::
* _ji_is_valid_widget::
* _ji_system_init::
* _ji_font_init::
* _jwindow_is_moving::
@end menu
@node _ji_get_widget_by_id, _ji_get_widget_array, jregion_intersect2, Funciones
@section _ji_get_widget_by_id
@ftable @asis
@item @t{JWidget _ji_get_widget_by_id (JID widget_id);}

@end ftable
@node _ji_get_widget_array, _ji_get_new_widget, _ji_get_widget_by_id, Funciones
@section _ji_get_widget_array
@ftable @asis
@item @t{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.

@end ftable
@node _ji_get_new_widget, _ji_free_widget, _ji_get_widget_array, Funciones
@section _ji_get_new_widget
@ftable @asis
@item @t{JWidget _ji_get_new_widget (void);}

@end ftable
@node _ji_free_widget, _ji_free_all_widgets, _ji_get_new_widget, Funciones
@section _ji_free_widget
@ftable @asis
@item @t{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.

@end ftable
@node _ji_free_all_widgets, _ji_is_valid_widget, _ji_free_widget, Funciones
@section _ji_free_all_widgets
@ftable @asis
@item @t{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).

@end ftable
@node _ji_is_valid_widget, _ji_system_init, _ji_free_all_widgets, Funciones
@section _ji_is_valid_widget
@ftable @asis
@item @t{bool _ji_is_valid_widget (JWidget widget);}

@end ftable
@node _ji_system_init, _ji_font_init, _ji_is_valid_widget, Funciones
@section _ji_system_init
@ftable @asis
@item @t{int _ji_system_init (void);}
@end ftable
@ftable @asis
@item @t{void _ji_system_exit (void);}

@end ftable
@node _ji_font_init, _jwindow_is_moving, _ji_system_init, Funciones
@section _ji_font_init
@ftable @asis
@item @t{int _ji_font_init (void);}
@end ftable
@ftable @asis
@item @t{void _ji_font_exit (void);}

@end ftable
@node _jwindow_is_moving, , _ji_font_init, Funciones
@section _jwindow_is_moving
@ftable @asis
@item @t{bool _jwindow_is_moving (void);}
Devuelve TRUE si en este momento el usuario está moviendo una
ventana.



@end ftable
@node Actualizaciones, Agradecimientos, Funciones, Top
@chapter 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/



@node Agradecimientos, Índice, Actualizaciones, Top
@chapter Agradecimientos

Gracias a:

@itemize @bullet
@item 
Shawn Hargreaves y a todos los que ayudaron con Allegro.
@item 
Richard M. Stallman y todo el mundo que participa en las proyectos GNU
como GCC, Emacs, etc.
@item 
David Turner, Robert Wilhelm, y Werner Lemberg por The FreeType library.
@end itemize



@ifinfo
@node Índice, , Agradecimientos, Top
@chapter Índice

@menu
* _ji_font_init::
* _ji_free_all_widgets::
* _ji_free_widget::
* _ji_get_new_widget::
* _ji_get_widget_array::
* _ji_get_widget_by_id::
* _ji_is_valid_widget::
* _ji_system_init::
* _jwindow_is_moving::
* jbox_new::
* jbutton_add_command::
* jbutton_add_command_data::
* jbutton_get_bevel::
* jbutton_new::
* jbutton_set_bevel::
* jbutton_set_icon::
* jbutton_set_icon_align::
* jcheck_new::
* jcheck_set_icon_align::
* ji_font_char_len::
* ji_font_get_aa_mode::
* ji_font_get_available_fixed_sizes::
* ji_font_get_char_extra_spacing::
* ji_font_get_size::
* ji_font_is_fixed::
* ji_font_load::
* ji_font_set_aa_mode::
* ji_font_set_char_extra_spacing::
* ji_font_set_size::
* ji_font_text_len::
* ji_get_default_manager::
* ji_load_widget::
* ji_register_widget_type::
* JI_SIGNAL_ADD_CHILD::
* JI_SIGNAL_BUTTON_SELECT::
* JI_SIGNAL_CHECK_CHANGE::
* JI_SIGNAL_DESELECT::
* JI_SIGNAL_DIRTY::
* JI_SIGNAL_DISABLE::
* JI_SIGNAL_ENABLE::
* JI_SIGNAL_ENTRY_CHANGE::
* JI_SIGNAL_GET_TEXT::
* JI_SIGNAL_HIDE::
* JI_SIGNAL_INIT_THEME::
* JI_SIGNAL_LISTBOX_CHANGE::
* JI_SIGNAL_LISTBOX_SELECT::
* JI_SIGNAL_MANAGER_ADD_WINDOW::
* JI_SIGNAL_MANAGER_EXTERNAL_CLOSE::
* JI_SIGNAL_MANAGER_IDLE::
* JI_SIGNAL_MANAGER_LOSTCHAR::
* JI_SIGNAL_MANAGER_REMOVE_WINDOW::
* JI_SIGNAL_MENUITEM_SELECT::
* JI_SIGNAL_NEW_PARENT::
* JI_SIGNAL_RADIO_CHANGE::
* JI_SIGNAL_REMOVE_CHILD::
* JI_SIGNAL_SELECT::
* JI_SIGNAL_SET_TEXT::
* JI_SIGNAL_SHOW::
* JI_SIGNAL_SLIDER_CHANGE::
* JI_SIGNAL_WINDOW_CLOSE::
* JI_SIGNAL_WINDOW_RESIZE::
* jlabel_new::
* jlist_alloc::
* jlist_append::
* jlist_concat::
* jlist_copy::
* jlist_delete_link::
* jlist_find::
* jlist_find_custom::
* jlist_first::
* jlist_foreach::
* jlist_free::
* jlist_free_1::
* jlist_index::
* jlist_insert::
* jlist_insert_before::
* jlist_insert_sorted::
* jlist_last::
* jlist_length::
* jlist_nth::
* jlist_nth_data::
* jlist_nth_prev::
* jlist_position::
* jlist_prepend::
* jlist_previous::
* jlist_remove::
* jlist_remove_all::
* jlist_remove_link::
* jlist_reverse::
* jlist_sort::
* jlist_sort_with_data::
* JM_BUTTONPRESSED::
* JM_BUTTONRELEASED::
* JM_CHAR::
* JM_CLOSE::
* JM_DESTROY::
* JM_DIRTYCHILDREN::
* JM_DOUBLECLICK::
* JM_DRAW::
* JM_DRAWRGN::
* JM_FOCUSENTER::
* JM_FOCUSLEAVE::
* JM_IDLE::
* JM_KEYPRESSED::
* JM_KEYRELEASED::
* JM_MOTION::
* JM_MOUSEENTER::
* JM_MOUSELEAVE::
* JM_OPEN::
* JM_REQSIZE::
* JM_SETPOS::
* JM_SIGNAL::
* JM_WHEEL::
* jmalloc::
* jmanager_attract_focus::
* jmanager_close_window::
* jmanager_dispatch_draw_messages::
* jmanager_dispatch_messages::
* jmanager_free::
* jmanager_free_focus::
* jmanager_free_widget::
* jmanager_get_capture::
* jmanager_get_focus::
* jmanager_get_mouse::
* jmanager_new::
* jmanager_open_window::
* jmanager_poll::
* jmanager_refresh_screen::
* jmanager_remove_message::
* jmanager_remove_messages_for::
* jmanager_run::
* jmanager_send_message::
* jmanager_set_capture::
* jmanager_set_focus::
* jmanager_set_mouse::
* jnew::
* jrect_add::
* jrect_copy::
* jrect_free::
* jrect_has_intersection::
* jrect_intersect::
* jrect_new::
* jrect_new_copy::
* jrect_replace::
* jrect_shrink::
* jrect_stretch::
* jregion_add::
* jregion_add2::
* jregion_clear::
* jregion_free::
* jregion_intersect::
* jregion_intersect2::
* jregion_join::
* jregion_move::
* jregion_new::
* jregion_new_copy::
* jregion_subtract::
* jregion_subtract2::
* jwidget_add_child::
* jwidget_add_childs::
* jwidget_add_hook::
* jwidget_autodestroy::
* jwidget_capture_mouse::
* jwidget_check_underscored::
* jwidget_close_window::
* jwidget_decorative::
* jwidget_dirty::
* jwidget_emit_signal::
* jwidget_enable::
* jwidget_expansive::
* jwidget_find_name::
* jwidget_flush_redraw::
* jwidget_focusrest::
* jwidget_free::
* jwidget_get_align::
* jwidget_get_bg_color::
* jwidget_get_child_position::
* jwidget_get_children::
* jwidget_get_data::
* jwidget_get_drawable_region::
* jwidget_get_font::
* jwidget_get_hook::
* jwidget_get_name::
* jwidget_get_parent::
* jwidget_get_parents::
* jwidget_get_position::
* jwidget_get_region::
* jwidget_get_text::
* jwidget_get_text_length::
* jwidget_get_texticon_info::
* jwidget_get_theme::
* jwidget_get_type::
* jwidget_get_window::
* jwidget_has_child::
* jwidget_has_focus::
* jwidget_init_theme::
* jwidget_is_enabled::
* jwidget_is_focusrest::
* jwidget_is_magnetic::
* jwidget_is_selected::
* jwidget_is_visible::
* jwidget_magnetic::
* jwidget_new::
* jwidget_noborders::
* jwidget_pick::
* jwidget_redraw_region::
* jwidget_release_mouse::
* jwidget_remove_child::
* jwidget_replace_child::
* jwidget_request_size::
* jwidget_select::
* jwidget_send_message::
* jwidget_send_message_after_type::
* jwidget_set_align::
* jwidget_set_bg_color::
* jwidget_set_border::
* jwidget_set_font::
* jwidget_set_name::
* jwidget_set_position::
* jwidget_set_static_size::
* jwidget_set_text::
* jwidget_set_theme::
* jwidget_show::
* jwidget_signal_on::
* jwindow_center::
* jwindow_close::
* jwindow_get_killer::
* jwindow_get_manager::
* jwindow_is_desktop::
* jwindow_is_foreground::
* jwindow_is_toplevel::
* jwindow_mobile::
* jwindow_new::
* jwindow_new_desktop::
* jwindow_open::
* jwindow_open_bg::
* jwindow_open_fg::
* jwindow_position::
* jwindow_remap::
* Widget's flags::
@end menu
@end ifinfo

@contents
@bye