[prev in list] [next in list] [prev in thread] [next in thread]
List: php-gtk-doc
Subject: [PHP-GTK-DOC] cvs: php-gtk-doc /es/userguide/chapters acknowledgements.xml installget.xml installuni
From: "Di Biase José Luis" <josx () php ! net>
Date: 2003-05-19 16:17:38
[Download RAW message or body]
josx Mon May 19 12:17:38 2003 EDT
Added files:
/php-gtk-doc/es/userguide/chapters acknowledgements.xml
installget.xml installunix.xml
installusage.xml
installwin32.xml introgtk.xml
introphpgtk.xml introphp.xml
signals.xml widgets.xml
Log:
["josx-20030519121738.txt" (text/plain)]
Index: php-gtk-doc/es/userguide/chapters/acknowledgements.xml
+++ php-gtk-doc/es/userguide/chapters/acknowledgements.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>
<chapter id="acknowledgements">
<title>Reconocimientos PHP-GTK</title>
<simpara>
La persona a la que quiero agradecer mas es a James Henstridge
&link.jhenstridge;, el auhor de PyGTK
(Python GTK+ Bindings). Su ayuda y advertencias fueron invauables durante
el desarrollo de esta extensión, y una parte del código
fuente esta basado e inspirado por su desarrollo en PyGTK.
</simpara>
<simpara>
Quiero agradecer también a el grupo de PHP por hacer un gran
lenguaje, y a el grupo GTK+ por el desarollo de el mejor grupo de
herramientas GUI basadas en C.
</simpara>
<simpara>
<author>
<firstname>Andrei</firstname><surname>Zmievski</surname>
</author>
- <literal>Feb 2001</literal>
</simpara>
</chapter>
Index: php-gtk-doc/es/userguide/chapters/installget.xml
+++ php-gtk-doc/es/userguide/chapters/installget.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>
<chapter id="installget">
<title>Consiguiendo la última versión</title>
<simpara>
El código fuente y los binarios para Windows de PHP-GTK
&version.phpgtk; pueden encontrase en
<ulink url="&url.phpgtk;">&url.phpgtk;</ulink>.
Los usuarios del código fuente ademas deberán
fijarse en la última versión de PHP en CVS - ver
<ulink url="&url.php.anoncvs;">&url.php.anoncvs;</ulink>.
</simpara>
</chapter>
Index: php-gtk-doc/es/userguide/chapters/installunix.xml
+++ php-gtk-doc/es/userguide/chapters/installunix.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>
<chapter id="installunix">
<title>Instalando PHP-GTK bajo Unix</title>
<para>
Los usuarios de Debian pueden descargar un binario de PHP-GTK desde
<ulink url="&url.debian;">&url.debian;</ulink>.
</para>
<para>
PHP GTK depende varios paquetes, los cuales necesitan esta instalados
antes de comenzar con lainstalación de PHP-GTK:
<itemizedlist>
<listitem>
<para>
PHP version &version.php; o posterior
</para>
</listitem>
<listitem>
<para>
Las bibliotecas GTK+, disponibles en
<ulink url="&url.gtk.download;">&url.gtk.download;</ulink>, o puedes
descargar un versió empaquetada de nuestros sistemas, e.j.
<literal>gtk</literal>
y <literal>gtk-devel</literal>
</para>
</listitem>
<listitem>
<simpara>
libtool, automake and autoconf. The combination of libtool 1.4.2,
automake 1.4 and autoconf 2.13 is known to work; mileage may vary
with other version combinations.
</simpara>
</listitem>
<listitem>
<para>
Para extras adicionales, descarga
<ulink url="&url.gtkhtml;">bibliotecas GtkHTML</ulink>,
<ulink url="&url.scintilla;">bibiotecas GtkScintilla</ulink> and
<ulink url="&url.pixbuf;">bibliotecas Gdk-Pixbuf</ulink>. Nuevamente,
estas estan disponibles empaquetadas en nuestro sistema, solo asegurate
de que hallas instalado en paquete de desarrollo.
GtkHTML, notablemente, tiene un número de sub-dependencia, e.j.
<literal>GAL</literal>, que también puede
serobtenido desde <ulink url="&url.gnome.ftp;">sitio ftp de Gnome</ulink>.
</para>
</listitem>
</itemizedlist>
</para>
<para>
Nosotros sugerimos que tomes el último código de
<ulink url="&url.phpgtk;">&url.phpgtk;</ulink> o desde un CSV anonimo
<ulink url="&url.php.anoncvs;">&url.php.anoncvs;</ulink>.
</para>
<para>
Ejecuta el script <command>./buildconf</command> que esta dentro de la
distribución. Esto hará la instalación necesaria de
archivos y creara el script <literal>configure</literal>. Luego, ejecuta
<command>./configure</command>. Este se fijará si tenes las
versions correctas de GTK+ 1.2.x (1.2.6 o superior, disponible de
<ulink url="&url.gtk.download;">&url.gtk.download;</ulink>) y otros
archivos requeridos para la compilación, y asi creará
los Makefiles necesarios.
</para>
<simpara>
<command>./configure</command> puede ser usado también para
construir widgets extras, e.jg.
<command>./configure --enable-scintilla --enable-gtkhtml</command>.
Para listar todas las opciones disponibles usa
<command>./configure --help</command>.
Recorda que cada widget extra tiene varias dependencias que son
necesarias para que la contrucción sea exitosa.
</simpara>
<simpara>
Finalmente, ejecuta <command>make</command> para compilar la
extensión. Algunos archivos fuentes son generados desde archivos
.defs por el generador de codigo. Si ves mensajes como
<literal>"Could not write..."</literal>, quiere decir que los
objetos GTK+ litados o sus caracteristicas todabia no son soportadas.
Si la compilación es exitosa,ejecuta
<command>make install</command> para instalar
la extensión en tu directorios por defecto de extensiones PHP
(habitualmente <filename>/usr/local/lib/php/extensions</filename>).
</simpara>
<para>
Errores: problemas comunes de <command>./configure</command> o
<command>make</command>
<itemizedlist>
<listitem>
<simpara>
<literal>./ltconfig: ltconfig : No such file or directory, configure:
error: libtool configure failed</literal> es causado por no tener
libtool, automake o autoconf instalado.
</simpara>
</listitem>
<listitem>
<simpara>
<literal>./aclocal.m4:813: error: m4_defn: undefined:
_m4_divert_diversion</literal> es causado por una incompatibilidad de
versiones de autoconf, mira las versiones recomendadas arriba.
</simpara>
</listitem>
<listitem>
<para>
<literal>php_gtk+.c:33: parse error before `TSRMLS_DC'</literal> es
causado ya sea por una versión vieja de PHP tratando de ser
encontrada por el sistema de contrucción o tratando de construir
php-gtk con una version antigua de PHP - por favor actualize la
versión de PHP &version.php; para arreglarlo.
</para>
</listitem>
<listitem>
<simpara>
<literal>gen_gtk.c:1: parse error before '<'</literal> es causado
por un error que ocurre en el generador. Habitualmente este error
se resuelve agregando una linea
<literal>ini_set("memory_limit", "32M");</literal>
a la primera linea de <filename>generator/generator.php</filename>.
Vos necesitas borrar todos los archivos <filename>gen_*</filename>
de todos los directorios despues de cambiar esto.
</simpara>
</listitem>
<listitem>
<simpara>
<literal>checking for gnome-config... Unknown library `gtkhtml'</literal>
(from <command>./configure</command>) e debido a un viejo y no disponible
archivo header de desarrollo - Si instalas desde un rpm o un paquete similar
necesitaras los paquetese <literal>-devel</literal>
</simpara>
</listitem>
<listitem>
<simpara>
<literal>Unable to find -lgal</literal> o mensaje similar es causado
por no tener la <literal>gal-devel</literal> o una biblioteca similar.
Habitualmente esto se debe a las sub dependencias de algunos widgets
mas complejos, como gtkhtml.
</simpara>
</listitem>
</itemizedlist>
</para>
<simpara>
Para probar la extensión, tenes que ejecutar los ejemplos de scripts
en el directorio <filename>test/</filename>. Estos sirven de demostraciones
de algunas de las formas de que la extensión PHP-GTK puede usarse.
</simpara>
</chapter>
Index: php-gtk-doc/es/userguide/chapters/installusage.xml
+++ php-gtk-doc/es/userguide/chapters/installusage.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>
<chapter id="installusage">
<title>¿ Como usar PHP-GTK ?</title>
<simpara>
Una aplicación PHP-GTK puede ejecutarse desde la linea de comandos
( o por en un archivos por lotes ) con la siguiente sintaxis:
<command>C:\php4\php -q C:\path\to\php-gtk\script.php</command>
</simpara>
</chapter>
Index: php-gtk-doc/es/userguide/chapters/installwin32.xml
+++ php-gtk-doc/es/userguide/chapters/installwin32.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>
<chapter id="installwin32">
<title>Instalando PHP-GTK bajo Windows</title>
<sect1 id="installwin32.intro"></sect1>
<sect1 id="install.win32.binaries">
<title>Descargando PHP-GTK</title>
<para>
Descarga los binarios win32 de PHP-GTK &version.phpgtk; de
<ulink url="&url.phpgtk;">&url.phpgtk;</ulink>. Ademas quieras
fijarte en los últimos fuentes del servidor de CSV de php.net. Ver
<ulink url="&url.php.anoncvs;">&url.php.anoncvs;</ulink> para más
información.
</para>
</sect1>
<sect1 id="install.win32.binary.package-layout">
<title>Disposición de la distribución Binaria</title>
<para>
La distribución binaria de PHP-GTK contiene la siguiente
estructura:
<itemizedlist>
<listitem>
<para>
<filename>\php4</filename> -> PHP dev y PHP-GTK
&version.phpgtk; archivos binarios
</para>
</listitem>
<listitem>
<simpara>
<filename>\winnt</filename> -> el archivos php.ini por defecto
</simpara>
</listitem>
<listitem>
<simpara>
<filename>\winnt\system32</filename> -> los binarios de GTK+ para
la extensión
</simpara>
</listitem>
<listitem>
<simpara>
<filename>\test</filename> -> algunos ejemplos de
demostración del uso de PHP-GTK
</simpara>
</listitem>
<listitem>
<simpara>
<filename>README.TXT</filename>
</simpara>
</listitem>
</itemizedlist>
</para>
</sect1>
<sect1 id="install.win32.howto">
<title>¿ Como instalarlo ?</title>
<orderedlist>
<listitem>
<simpara>
Si es una instalación nueva deberia crear
<filename>C:\php4</filename> y cpoiarle los archivos de
<filename>\php4</filename> a este directorio. Si tiene una
instalación anterior de PHP (por ejemplo, con Apache) o intento
tenerla, necesita poner su archivo <filename>php.ini</filename> aqui
también. Los archivos que se encuentran en esta carpeta son por
defecto de PHP o relacionados con con PHP-GTK y seran todos necesarios
para actualizarlo. Fijese que <filename>C:\php4</filename> es el
directorio por defecto y que si instala PHP-GTK en otro lugar va a
necesitar especificar el camino comleto en su extension_dir en la
copia de <filename>php.ini</filename> que es usado por PHP.
</simpara>
</listitem>
<listitem>
<simpara>
Copie el contenido de <filename>\winnt\system32</filename> a su directorio
system32. En Windows NT y Windows 2000 es
<filename>C:\winnt\system32</filename>. En Windows 95/98 puede ser
<filename>C:\Windows\system</filename> o
<filename>C:\Windows\system32</filename>. Este grupo de archivos esta
relacionado con GTK y no será necesario actualizar hasta que
PHP-GTK2 sea lanzado.
</simpara>
</listitem>
<listitem>
<simpara>
Copia el contenidos de <filename>\test</filename> a la direcció
donde queres correr los scripts (e.j. <filename>C:\php4\test</filename>).
</simpara>
</listitem>
</orderedlist>
</sect1>
</chapter>
Index: php-gtk-doc/es/userguide/chapters/introgtk.xml
+++ php-gtk-doc/es/userguide/chapters/introgtk.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>
<chapter id="introgtk">
<title>¿ Qué es GTK+?</title>
<sect1 id="gtk.intro"></sect1>
<sect1 id="intro.whatis.gtk.history">
<title>Historia de GTK+</title>
<para>
GTK+ fue originalmente desarrollado para
<ulink url="&url.gimp;">GIMP</ulink>, el
<ulink url="&url.gnu;">GNU</ulink> Image Manipulation Program.
GTK+ quiere decir GIMP Tool Kit. GTK+ ha crecido desde estos principios
y actualmente es usado como parte centra de
<ulink url="&url.gnome;">Gnome</ulink>, el entorno de escritorio del
Proyecto GNU. GTK+ también ha sido portado a BeOS y Win32,
haciendolo la perfecta elección para usarlo como base para una
extensión de PHP, manteniendo a PHP lo mas multiplataforma posible
y permitiendo la creación de aplicaciones con ventanas en PHP para
Linux, BeOS y Windows.
</para>
</sect1>
<sect1 id="intro.whatis.gtk.whatitdoes">
<title>¿ Qué hace GTK+ ?</title>
<simpara>
GTK+ es un conjunto de bibliotecas escritas en C para crear interfases
graficas de usuario. Tiene un arquitectura orientada a objetos desarrollada
en tres bibliotecas:
</simpara>
<para>
<itemizedlist>
<listitem>
<simpara>
<emphasis>GLib</emphasis>
</simpara>
<simpara>
brinda varias heramientas para usar cuando se programa con GTK+.
</simpara>
</listitem>
<listitem>
<simpara>
<emphasis>GDK</emphasis>
</simpara>
<simpara>
abstrae la funciones de dibujo de ventanas de bajo nivel
</simpara>
</listitem>
<listitem>
<simpara>
<emphasis>GTK</emphasis>
</simpara>
<simpara>
brinda un conjunto de widgets para usar cuando creas tus GUI.
</simpara>
</listitem>
</itemizedlist>
</para>
</sect1>
</chapter>
Index: php-gtk-doc/es/userguide/chapters/introphpgtk.xml
+++ php-gtk-doc/es/userguide/chapters/introphpgtk.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>
<chapter id="introphpgtk">
<title>¿ Qu´ es PHP-GTK?</title>
<simpara>
PHP-GTK es una <ulink url="&url.php;">PHP</ulink> extención que
permite escribir aplicaciones gráficas multiplataforma del tipo
cliente. Esta es la primera extensión de
<ulink url="&url.php;">PHP</ulink> de esta clase,
y fue escrita en parte para probar que <ulink url="&url.php;">PHP</ulink> es
un lenguaje de proposito general , y que ademas es mucho mas que solo un
entorno de desarrollo de aplicaciones web.
</simpara>
<simpara>
Esta extensión <emphasis>no</emphasis> permite mostrar una
aplicació GTK+ en navegador de internet. Se utiliza para crear
aplicaiones GUI completas independientes del navegador de internet .
</simpara>
</chapter>
Index: php-gtk-doc/es/userguide/chapters/introphp.xml
+++ php-gtk-doc/es/userguide/chapters/introphp.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>
<chapter id="introphp">
<title>¿ Qué es PHP?</title>
<sect1 id="php.intro"></sect1>
<sect1 id="intro.whatis.php.history">
<title>Historia de PHP</title>
<simpara>
<ulink url="&url.php;">PHP</ulink> comenzo y sigue siendo primeramente
usado como un lenguaje de script del lado del servidor embebido en HTML.
</simpara>
<simpara>
PHP, se conoce originalmente como Personal Home Pages, fue concevido
en el otoño de 1994 por Rasmus Lerdorf. El lo escribio como una forma
de track visitantes a su CV en linea. La primera version salió
en los comienzos de 1995, y fue ahi donde Rasmus se dió cuenta que
haciendo en proyecto codigo-abierto, las personas arreglarián sus
problemas. La primera versión fue muy precaria y tenia un parser
que reconocia solo unas pocas macros y brindaba algunas utilidades que se
usaban comunmente en sitios web.
</simpara>
<simpara>
El parser fue reescrito a mediados de 1995 y se lo renombro a PHP/FI
version 2. El "FI" en esta versió queria decir Interprete formal.
Lo que Rasmus habia agregado a PHP fue deacuerdo a las necesidades
crecientes de los sitio web. El soporte para mSQL fue agregado. PHP/FI
tubo un crecimiento masivo, y otra gente empezo a contribuir programadno
regularmente.
</simpara>
<simpara>
A mediados de 1997 Zeev Suraski y Andi Gutmans reescribieron el parser
principal, y PHP cambio de estar en manos de Rasmus a un grupo mas
orientado al proyecto. Esto formo las bases para que PHP3, fuere ahora
llamado PHP: Hypertext Preprocessor - un acronimo recursivo.
</simpara>
<simpara>
La última versió, de PHP4, es otra reescritura de Suraski and
Gutmans y esta basada en el motor <ulink url="&url.zend;">Zend</ulink>.
PHP ahora tiene doscientos contribuyentes regularmente trabajando en
varias partes del proyecto. Tiene una cantidad muy grande extensiones,
modulos y soporta todos los servidores más populares nativamente,
y ademas tiene soporte para MySql y ODBC.
</simpara>
<simpara>
Las últimas estadisticas muestran que PHP es actualmente usado por
más de 5.5 millones de dominios, y ha tenido un gran crecimiento
durante el último año. Es lejos el módulo más
popular de Apache; para dar algun perspectiva, Apache actualmente
tiene un 60% del mercado de servidores de internet, y el servidor IIS
( con soporte nativo para ASP) tiene menos de la mitad de esa
proporción del mercado.
(Figuras tomadas de <ulink url="&url.stats;">&url.stats;</ulink>
Marzo 2001.)
</simpara>
</sect1>
<sect1 id="intro.whatis.php.whatdoes">
<title>¿ Qué hace PHP ?</title>
<simpara>
PHP es un lenguaje de proposito general. Es normalmente usado como un
lenguaje de script embebido en HTML para su uso en la web, pero puede
también puede usarse como un lenguaje de script para shell o
hasta como un lenguaje para escribir aplicaciones con ventanas, con
PHP-GTK.
</simpara>
<simpara>
Debido a la naturaleza open-source de PHP, si hay algo que actualmente
no se pueda hacer en PHP no hay ningun impedimento para que vos puedas
escribir un módulo o una extensión en código C para
extender la funcionalidad y puedas utilizar PHP con lo que vos quieras.
Esto es posible por la buen documentación de la API que esta disponible
para todos.
</simpara>
<para>
PHP4 tiene dos partes:
<itemizedlist>
<listitem>
<simpara>
<emphasis>El motor Zend</emphasis>
</simpara>
<simpara>
es la parte del paquete PHP que mantiene los pedidos, los procesos de los
archivos de script y maneja las variable y los recursos. Su sitio puede
encontrarse en <ulink url="&url.zend;">&url.zend;</ulink>.
</simpara>
</listitem>
<listitem>
<simpara>
<emphasis>PHP</emphasis>
</simpara>
<simpara>
implementa el 90% de la funcionalidad que ve el usuario final. Brinda
un amplio rango de módulos como el soporte para MySQL, ODBC and
XML.
</simpara>
</listitem>
</itemizedlist>
</para>
</sect1>
</chapter>
Index: php-gtk-doc/es/userguide/chapters/signals.xml
+++ php-gtk-doc/es/userguide/chapters/signals.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>
<chapter id="gtk.signals">
<title>Signals and Callbacks</title>
<sect1 id="gtk.signals.whatare">
<title>¿ Qué son las Señales?</title>
<simpara>
<emphasis>Las señales son notificaciones emitidas a los
<link linkend="gtk.widgets.whatare">widgets</link>.</emphasis>
</simpara>
<simpara>
Cuando uno porgrama interfases graficas de usuario
(<acronym>GUI</acronym>),
usualmente es necesario responder a acciones que genera el usuario o el
programa por si solo. <acronym>GNOME</acronym> y <acronym>GTK+</acronym>
hacen esto por medio del uso de señales. Las señales se
usan para permitir a el programa conocer que algo ocurrio. Esto puede ser,
por ejemplo, un usuario presionando un <classname>GtkButton</classname>,
o un cambio hecho a un valor de <classname>GtkAdjustment</classname>.
</simpara>
<simpara>
Un programa, causa a <classname>GtkAdjustment</classname> emitir su
señal de <signalname>value-changed</signalname> cuando un widget
cambia uno de sus valores de ajuste. Esta señal en particular es
usada interna y externamente en <classname>GtkAdjustment</classname>, por
eso no es siempre necesario escribir que esa señal en el codigo
diga que <classname>GtkProgressBar</classname> la use. Una situació
mas obvia ocurre cuando un usuario presiona sobre una instancia de
<classname>GtkButton</classname>, causando que el widget del boton emita
la señal de <signalname>clicked</signalname>. Como programdador,
podes utilizar <link linkend="gtk.callbacks.whatare">callbacks</link> para
hacer algo a cada señal emitada por un widget.
</simpara>
</sect1>
<sect1 id="gtk.callbacks.whatare">
<title>¿ Qué son Callbacks?</title>
<simpara>
<emphasis>
Callbacks son funciones que son invocadas cuando las
<link linkend="gtk.signals.whatare">señales</link> se emiten por
los <link linkend="gtk.widgets.whatare">widgets</link>.
</emphasis>
</simpara>
<simpara>
Callbacks son funciones que son creadas por los programadores para
reaccionar a las señales emitadas por los widgets. Vos
especificas la función que deberia llamarse para
<link linkend="gtk.signals.connection">conectar</link> la fucnión
a la señal.
</simpara>
<simpara>
Callback también se conoce como el manejador de la señal.
Esto puede ser el <literal>manejador por defecto</literal> de un widget
o un <literal>manejador definido porel usuario</literal>, que es, una
función escrita por el programador.
</simpara>
</sect1>
<sect1 id="gtk.signal.inheritance">
<title>Herencia de señales</title>
<simpara>
Las señales son heredadas por los objetos, como los son los
métodos. Un widget puede emitir alguna señal que su objeto
ancestro tiene definida, comotambén sus propias especificas.
</simpara>
<simpara>
Hay casos donde las señales no son relevantes a los widgets, no
existirá ningun mesaje de error cuando la señal se llame -
pero igualmente no habrá una significado obvio para el widget al
emitir esa señal en particular.
</simpara>
</sect1>
<sect1 id="gtk.signals.connection">
<title>Conectando Señales</title>
<sect1 id="gtk.signals.connection.simple">
<title>Conecciones simples</title>
<simpara>
Para reaccionar a una señal debes conectarla especificando una
función callback para que PHP-GTK la llame cuando la señal se
emita.
</simpara>
<simpara>
Al conectar una función a una señal se logra llamar el metodo
<function class="GtkObject">connect()</function> del objeto.
</simpara>
<simpara>
La función que pones como callback para una señal debe tener su
prototipo correcto. Podes encontrar el prototipo que deberia tener en
las sección de <link linkend="reference">referencia</link> de
este manual.
</simpara>
<simpara>
Por ejemplo, si yo quisiera conectar una señal
<signalname>clicked</signalname> de una instancia de
<classname>GtkButton</classname> deberia definir una función que
acepte un parametro, el cual sera el boton que se presiono.
</simpara>
<para>
El codigo debajo muetsra como se crea una ventana, se agrega un boton
a ella y se espera por si se presiona. Cuando se presiona el boton, se
abre una nueva <classname>GtkWindow</classname> conteniendo un mensaje.
<example>
<title>Señales y Callbacks</title>
<programlisting role="php">
function shutdown()
{
print("Shutting down...\n");
gtk::main_quit();
}
function you_clicked($button)
{
$window = &new GtkWindow();
$label = &new GtkLabel("You clicked the button");
$window->add($label);
$window->connect("destroy","shutdown");
$window->show_all();
return false;
}
$window = &new GtkWindow();
$window->connect("destroy", "shutdown");
$window->set_border_width(10);
$button = &new GtkButton("Click Me!!");
$button->connect("clicked", "you_clicked");
$window->add($button);
$window->show_all();
gtk::main();
</programlisting>
</example>
</para>
<para>
La parte importante aqui es donde llamamos
<informalexample>
<programlisting role="php">$button->connect();</programlisting>
</informalexample>
El metodo de conección aqyi registra la función
<literal>you_clicked()</literal> como el callback que será
invocado cuando la señal <signalname>clicked</signalname> sea emitida
por el widget <classname>GtkButton</classname>. Nosotros ademas
registramos la función <literal>shutdown()</literal> como
manejador de la señal <signalname>destroy</signalname> para ambas
ventanas asi podemos cerrar la aplicación correctamente.
</para>
</sect1>
<sect1 id="gtk.signals.connection.multiple">
<title>Multiples coneccciones</title>
<simpara>
Con PHP-GTK podes registar mas deuna función para ser invocada
cuando una señal sea emitida por un widget. Esto te permite poner un
conjunto de funciones para ser llamadas en respuesta un acción
esperada.
</simpara>
<para>
Cuando mas de una función se conecta a una señal, las funciones
son llamadas en el orden en que fueron registradas cuando la señal sea
emitida.
<example>
<title>Ordenes Callback de señales</title>
<programlisting role="php">
function first($button)
{
print "First function has been called\n";
}
function second($button)
{
print "Second function has been called\n";
}
$window = &new GtkWindow();
$window->connect_object("destroy", array("gtk",
"main_quit"));
$button = &new GtkButton("Click Me!!");
$button->connect("clicked","first");
$button->connect("clicked","second");
$window->add($button);
$window->show_all();
gtk::main();
</programlisting>
</example>
En el ejemplo de arriba conectamos dos funciones a una señal
<signalname>clicked</signalname> de un boton. La primera llamada al
método <function class="GtkObject">connect()</function> conecta
la señal <signalname>clicked</signalname> a la función
<literal>first()</literal>, la segunda llamada conecta la señal
<signalname>clicked</signalname> a la función
<literal>second()</literal>.
</para>
<para>
La saluda de este programa seria:
<programlisting>
First function has been called.
Second function has been called.
</programlisting>
</para>
</sect1>
</sect1>
<sect1 id="gtk.signals.custom.params">
<title>Usandon parametros personalizados</title>
<sect1 id="gtk.signals.custom.data">
<title>Pasando datos personalizados como parametro</title>
<simpara>
Caundo <link linkend="gtk.signals.connection">conectamos</link> las
señales, esposibe sumar un parametro extra personalizado a callback.
Esto es muy beneficioso para pasar el objeto que quieres para ejecutar
una acción a la función callback.
</simpara>
<simpara>
Por ejemplo, cuando un boton se presiona querriamos destruir la instancia
padre de <classname>GtkWindow</classname> que la instancia de
<classname>GtkButton</classname> habia
<function class="gtkcontainer">sumado</function>.
</simpara>
<simpara>
Podes hacer esto incluyendo un tercer parametro opcional a llamada a
<function class="GtkObject">connect()</function>. ESto sera pasado a la
funcion que maneja la señal como el parametro final del callback.
</simpara>
<para>
<example>
<title>
Usando parametros personalizados con el método
<function class="GtkObject">connect()</function>.
</title>
<programlisting role="php">
function button_clicked($button, $window)
{
$window->destroy();
gtk::main_quit();
}
$window = &new GtkWindow();
$button = &new GtkButton("exit");
$button->connect("clicked","button_clicked", $window);
$window->add($button);
$window->show_all();
gtk::main();
</programlisting>
</example>
En el ejemplo anterior podes ver que no solo pasamos la variable
<literal>$button</literal> , una instancia de
<classname>GtkButton</classname>, a el callback
<signalname>clicked</signalname> pero ademas pasamos la variable
<literal>$window</literal>, una instancia de la clase
<classname>GtkWindow</classname>. Esto nos permite llamar a el
método <function class="GtkObject">destroy()</function> en la
ventana.
</para>
<note>
<simpara>
Podes tener tantos parametros personalizados como quieras.
</simpara>
</note>
<para>
Si se pasa la variablee <literal>$button</literal> como nuestro
parametro objeto llamador y la variable <literal>$window</literal>
como nuestro parametro personalizado, podemos entonces utilizar la
misma callback para mas de un <classname>GtkButton</classname> o mas
de una <classname>GtkWindow</classname>. Fijese que los nombres dados
a los parametros dentro de callback son irrelevantes fuera de la
función de callback; PHP-GTK se fija la posición de los
parametros en el método connect*, luego llama y pasa estos
parametros a las variables listadas en la declaración del
callback como un array, por eso cada instancia de la conección
usando la misma estructura de parametros puedes usar el mismo callback.
Esto se demuestra en el codigo abajo usando solo un parametro
personalizado, pero es igualmente cierto para mas de uno.
<example>
<title>Usando el mismo callback para mas de una ventana</title>
<programlisting role="php">
function button_clicked($button, $window)
{
$window->set_title("titled");
}
$window1 = &new GtkWindow();
$window1->connect_object("destroy", array("gtk",
"main_quit"));
$window2 = &new GtkWindow();
$window2->connect_object("destroy", array("gtk",
"main_quit"));
$button1 = &new GtkButton("click me");
$button2 = &new GtkButton("or me");
$button1->connect("clicked", "button_clicked",
$window1);
$button2->connect("clicked", "button_clicked",
$window2);
$window1->add($button1);
$window2->add($button2);
$window1->show_all();
$window2->show_all();
gtk::main();
</programlisting>
</example>
</para>
</sect1>
<sect1 id="gtk.signals.connect.object">
<title>Usando los métodos connect_object*</title>
<para>
Ambos <function class="GtkObject">connect_object()</function> y
<function class="GtkObject">connect_object_after()</function> permiten
pasar un objeto distinto a el objeto que llama como primer parametro
enviado a la función callback. Esto es principalmente usado
llamando funciones estaticas de PHP-GTK, como en (por ejemplo) la
función <function>gtk::main_quit()</function>:
<example>
<title>
Usando el método
<function class="GtkObject">connect_object()</function>
para especificar la función como callback.
</title>
<programlisting role="php">
$window = &new GtkWindow();
$window->connect_object("destroy", array("gtk",
"main_quit"));
$window->show();
gtk::main();
</programlisting>
</example>
Podria ser llamado con una funcion estatca o un metodo usando la
sintaxis <literal>gtkobject::method</literal> expresada como un array.
</para>
<para>
Tambien quiere decir que puede tener una sola callback para multiple
señales. Por ejemplo, podrias crear una ventan que contenga (dentro de
los widgets necesarios) una <classname>GtkMenuBar</classname>, una
<classname>GtkToolbar</classname> y un <classname>GtkButton</classname>.
Cuando elije <literal>Exit</literal> el usuario de cualquier de esos
widgets una función de shutdown podria invorcarse pasandolo la
instancia de <classname>GtkWindow</classname> como primer parametro,
permitiendo asi que la ventana sea destruida desde cualquiera de sus
conecciones. La función callback y sus conecciones en esta
instancia se verian de la siguiente manera:
<example>
<title>
Usando el método
<function class="GtkObject">connect_object()</function>
para pasar otro objeto como primer parametro.
</title>
<programlisting role="php">
function destroy_window($window)
{
$window->destroy();
gtk::main_quit();
}
$exit_button->connect_object("clicked",
"destroy_window", $window);
</programlisting>
</example>
</para>
<para>
El método connect_after* permite a las funciones ser
"ejecutadas luego" de la señal por defecto para esa señal.
Esto puede ser muy bueno en algunas situaciones; por ejemplo, donde uno
quiere destruir solamente una de tantas ventanas en una cirscunstancia
dada. De todas formas, los métodos connect_after* solo
funcionarán cuando una señal ha sido creada en el codigo GTK con
un flag <literal>GTK_RUN_LAST</literal>. La señal
<signalname>destroy</signalname> y todas sus señales
<literal>'event'</literal> tienen este flag; mas alla de esto,
la única manera de saberlo es testeando la señal dentro de
PHP-GTK o leyendo el codigo GTK.
<example>
<title>Usando elmétodo
<function class="GtkObject">connect_after()</function>
</title>
<programlisting role="php">
function quit_routine($window)
{
print("Shutting down...\n");
gtk::main_quit();
}
$window1 = &new GtkWindow();
$window1->set_title("Quit the main loop");
$window1->connect("destroy", "quit_routine");
$window2 = &new GtkWindow();
$window2->set_title("Destroy this window");
$window2->connect_after("destroy", "quit_routine");
$window1->show();
$window2->show();
gtk::main();
</programlisting>
</example>
</para>
<simpara>
Ver también: <classname>GtkObject</classname>,
<function class="GtkObject">connect_after()</function>
<function class="GtkObject">connect_object()</function> y
<function class="GtkObject">connect_object_after()</function>.
</simpara>
</sect1>
</sect1>
<sect1 id="gtk.signals.events">
<title>Señales y Eventos</title>
<simpara>
<emphasis>Señales GTK, Eventos GDK.</emphasis>
</simpara>
<simpara>
Las señales no son eventos, y los eventos no son señales. Una señal es
un mensaje emitido por una instancia de <classname>GtkObject</classname>
en respuesta a algun elemento predeterminado de su ambiente, e.j. una
acción generada por el usuario final, o una instrucción
generada desde una función o método. Las señales son
siempre programadas en en codigo, o internamente dentro de GTK o
externamente por el programador PHP-GTK.
</simpara>
<simpara>
Los eventos, por otro lado, son un continuo flujo de impulsos de
comunación de mensajes que dejan ver cambios en el ambiente en
el sistema de ventanas. El ciclo pricipal de PHP-GTK esta hecho de estos
flujos de eventos entre otras cosas.
</simpara>
<note>
<simpara>
No es posible conectar una función callback a un
<classname>GdkEvent</classname> directamente.
</simpara>
</note>
<simpara>
Cualquier widget que tiene su <classname>GdkWindow</classname> puede
capturar eventos que son reelevantes para el. Los Widgets que carecen de
una <classname>GdkWindow</classname> - esos que son creados con el flag
<literal>GTK_NO_WINDOW</literal> - no pueden hacer eso, a menos que sean
contenidos dentro de un <classname>GtkEventBox</classname> - un widget
creado con proposito especifico. Hay ocaciones cuando es muy favorable
permitir la captura de eventos; un ejemplo obvio seria la creación
de una instancia de <classname>GtkToolTips</classname> la cual se dispara
cuando su subject widget captura el evento
<literal>GDK_ENTER_NOTIFY</literal> y destruido cuando el mismo widget
captura el evento <literal>GDK_LEAVE_NOTIFY</literal>.
</simpara>
<simpara>
Aunque no es posible usa run evento como disparador de un callback de la
misma forma que una señal, hay una serie de señales que derivan de
<classname>GtkWidget</classname> colectivamente conocidos como
<literal>'event' signals</literal>. Estos son formas efectivamente de
descriibir un evento en terminos de una señal, permitiendo a las
callbacks ser indirectamente disparadas por medio de la captura de la
ocurrencia de las mayoria de los <enumname>GdkEventTypes</enumname>.
El objeto <classname>GtkTooltips</classname> por si mismo utiliza el
método <function class="GktObject">connect_object()</function> y
la señal generica <signalname>event</signalname> para monitorear su
subject widget.
</simpara>
<para>
El concepto de events no es f´cil de entender. Por favor copie,
pegue y ejecute el siguiente script para ver como se muestran los eventos
sobre la acción de los widgets.
<example>
<title>Demonstración del flujo de los eventos de un
<classname>GtkButton</classname>
</title>
<programlisting role="php">
dl("php_gtk." . (strstr(PHP_OS, "WIN") ? "dll" :
"so")) ||
die("Can't load php_gtk module!\n");
function show_event_type($button, $event, $text)
{
$event_type = $event->type;
$insert = $text->get_length();
$text->freeze();
switch($event_type) {
case 2:
$text->insert_text("GDK_EXPOSE\n", $insert);
break;
case 3:
$text->insert_text("GDK_MOTION_NOTIFY\n", $insert);
break;
case 4:
$text->insert_text("GDK_BUTTON_PRESS\n", $insert);
break;
case 5:
$text->insert_text("GDK_2BUTTON_PRESS\n", $insert);
$button->hide();
break;
case 7:
$text->insert_text("GDK_BUTTON_RELEASE\n", $insert);
break;
case 8:
$text->insert_text("GDK_KEY_PRESS\n", $insert);
break;
case 9:
$text->insert_text("GDK_KEY_RELEASE\n", $insert);
break;
case 10:
$text->insert_text("GDK_ENTER_NOTIFY\n", $insert);
break;
case 11:
$text->insert_text("GDK_LEAVE_NOTIFY\n", $insert);
break;
case 12:
$text->insert_text("GDK_FOCUS_CHANGE\n", $insert);
break;
case 14:
$text->insert_text("GDK_MAP\n", $insert);
break;
case 15:
$text->insert_text("GDK_UNMAP\n", $insert);
$button->destroy();
$text->insert_text(
"\n* GDK EVENTS AND GTK SIGNALS - background stream vs foreground
messaging *
\n
* Most GdkEventTypes have counterpart GTK signals, known as 'event'
signals, implemented in GtkWidget. The types on your screen are there
because the GtkButton was programmed to emit the generic 'event' signal
each time it captured one of the stream of GDK events that makes up the
GTK main loop. In each case, the captured GdkEvent was passed as a
callback parameter so that its enumerated type value could be determined
within the signal handler function. Scroll down to see the series of event
values captured during your recent interaction with the GtkButton widget. *
\n
* Please note that the majority of GTK signals do NOT correspond to GDK
events in this or any other way! For example, the signal connection
\$button->connect('pressed', 'whatever');
has no relationship to the GDK_BUTTON_PRESS event it generates, which
refers to mouse-button activity and not to the GtkButton 'pressed' signal. *
\n", 0);
break;
}
$text->thaw();
return false;
}
$window = &new GtkWindow();
$window->set_position(GTK_WIN_POS_CENTER);
$window->set_default_size((gdk::screen_width()/1.5),
(gdk::screen_height()-20));
$window->connect_object("destroy", array("gtk",
"main_quit"));
$window->realize();
$box = &new GtkVBox(false, 5);
$window->add($box);
$scrlwin = &new GtkScrolledWindow();
$box->pack_start($scrlwin, true, true, 0);
$text = &new GtkText();
$scrlwin->add($text);
$button = &new GtkButton("Double-click here for information..");
$button->add_events(GDK_ALL_EVENTS_MASK);
$button->connect("event", "show_event_type", $text);
$box->pack_end($button, false, false, 5);
$window->show_all();
gtk::main();
</programlisting>
</example>
</para>
</sect1>
</chapter>
<!--
* Local variables:
* tab-width: 1
* c-basic-offset: 1
* fileformat=unix
* End:
* vim600: et sw=1 ts=1 tw=78 fdm=indent
* vim<600: et sw=1 ts=1 tw=78
-->
Index: php-gtk-doc/es/userguide/chapters/widgets.xml
+++ php-gtk-doc/es/userguide/chapters/widgets.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>
<chapter id="gtk.widgets">
<title>Widgets y Containers</title>
<sect1 id="gtk.widgets.intro">
<title>Introducción</title>
<simpara>
Este cápitulo explicará algunos conceptos de GTK+ y como usarlo.
</simpara>
</sect1>
<sect1 id="gtk.widgets.whatare">
<title>¿ Qué son los Widgets?</title>
<simpara>
<literal>widget</literal> es un termino utilizado en el mundo de X para
cualquier interfase de usuario. Un widget puede ser una caja de texto,
una etiqueta, un marco, una ventana o cualquier otro componente
de la GUI. Los GTK widgets derivan todos de una clase base abstracta
<classname>GtkWidget</classname>, y heredan métodos, señales y
propiedades implentadas.
</simpara>
<simpara>
Desde el punto de vista de la programación un widget tiene cinco
partes en su ciclo de vida:
</simpara>
<para>
<orderedlist>
<listitem>
<simpara>Creación</simpara>
<simpara>
En PHP-GTK esto es hecho creando un objeto, e.j.
<literal>$window = &new GtkWindow();</literal>
</simpara>
</listitem>
<listitem>
<simpara>Colocación</simpara>
<simpara>
Este es el paso en el cual se suma un widget a un
<link linkend="gtk.containers.whatare">container</link>. Esto se
logra especificamente en PHP-GTK usando la siguiente sintaxis
<literal>$container->add($widget);</literal>
</simpara>
</listitem>
<listitem>
<simpara>Conección de la señal</simpara>
<simpara>
En este paso se escribe la función de regreso para usar. Un
ejemplo de ello podria ser
<literal>
$widget->connect("event", "my_focus_func");
</literal>,
donde "event" es un estado predefinifo como
<signalname>clicked</signalname> y "my_focus_func" es la
llamada a la subrutina.
</simpara>
</listitem>
<listitem>
<simpara>exhibición</simpara>
<simpara>
Describe si el widget esta en la pantalla del usuario.
Se realiza llamando a
<literal>$widget->show();</literal> y finalizando con
<literal>$widget->hide();</literal>.
</simpara>
</listitem>
<listitem>
<simpara>Destrucción</simpara>
<simpara>
Esto ocurre cuando la función <function>gtk::main_quit()</function>
se llama. Todas las acciones necesarias para ello son manejadas internamente.
</simpara>
</listitem>
</orderedlist>
</para>
</sect1>
<sect1 id="gtk.containers.whatare">
<title>¿ Qué son los Containers?</title>
<simpara>
Un container es simplemente un <link linkend="gtk.widgets.whatare">widget</link>
que puede contener otro widget. La gran mayoria de widgets caen dentro de esta
clase; ejemplos obvios son <classname>GtkWindow</classname>,
<classname>GtkTable</classname> y <classname>GtkBox</classname>.
Ademas de esta propiedad son exactamente iguales a otros widgets, y pueden
sumarseles a otros containers como asi también el soporte de widgets hijos.
Son derivados de la clase base <classname>GtkContainer</classname>,
que es derivada de la clase <classname>GtkWidget</classname>.
</simpara>
</sect1>
</chapter>
--
PHP-GTK Documentation Mailing List (http://gtk.php.net/)
To unsubscribe, visit: http://www.php.net/unsub.php
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic