Nos obligan a molestarte con la obviedad de que este sitio usa cookies OK | Más información
receptor viark

Chincheta Autor Tema: Enigma 1, la biblia en español  (Leído 8206 veces)

06/05/2008, 20:23 -

Enigma 1, la biblia en español

Registrado:
17/01/2008
Gracias:
140/2100
Mensajes
20506
Enigma 1, la biblia en español!

A continuacion os dejo la traducción al español de la biblia Enigma 1 realizada por un servidor, de momento solo tengo hasta la lección 3, en breve la tendre completada, espero que haya paciencia.
Un saludo a todo el mundo. A programar!!!!

   :o   k:

Enigma1 La biblia
/*
+--------------------------------------------------------------------------
| La Biblia Enigma1 Tutorial
| ========================================
| Por: Bacicciosat aka Meo aka Luponero
| Traduccion: Nesi_tor
|
| Tutorial de entorno de la APIS de Enigma1 con codigo fuentes y comentarios
| (c) august 2006 by Meo
|
+---------------------------------------------------------------------------
*/

Atencion: No puedes modificar, redistribuir o publicar este tutorial en otro sitio sin la cabecera ni los creditos de Bacicciosat.

Indice:

1. Configuracion de entorno de desarrollo para compilar tu codigo
2. Vision de la estructura de la aplicación
3. Leccion 1: Ventana "Hello World" (Hola mundo!)
4. Leccion 2: Botones
5. Leccion 3: Campo de mensaje
6. Leccion 4: Entrada de texto
7. Leccion 5: Campo de chequeo
8. Leccion 6: Campo de lista
9. Leccion 7: Campo combo
10. Leccion 8: Conexión HTTP y Descarga

Este tutorial no pretende ser una explicacion exhaustiva sobre todas las funciones de Enigma. Todas estan en C++ y son muy faciles de usar.
El unico problema es que la API no esta documentada.

Este tutorial tiene el objetivo de describir el entorno principal de las APIS Enigma.
Cada leccion explica un objeto del entorno con las llamadas principales a objetos, metodos y flags(se usan para designar estados en programacion).
Todas las lecciones estan acompañadas de ejemplos de codigo, capturas, fuentes y un ejemplo de compilacion del codigo.

Vamos a empezar.

nesi_tor 06/05/08 14:21:31

--------------------------------------------------------------------------------

1. Configuracion de entorno de desarrollo para compilar tu codigo

Antes de empezar a aprender Enigma necesitas un entorno para compilar.
Fuentes y codigo de prueba
Necesitas:
1) Un PC con Linux opsys
2) enigma CDK

Atencion: Si instalas el Enigma CDK siguiendo estas intrucciones y usando el directorio /dream pueden compilar todas los codigos de ejemplo con el makefile subministrado. Ademas tienes que cambiar paths en el makefile de acuerdo con tu instalacion de CDK.

Instrucciones para configurar tu entorno.

1) Asegurate de que tienes instalado en tu Pc una distribución reciente de Linux con los siguientes paquetes:
- cvs
- autoconf >= 2.57a
- automake >= 1.8
- libtool >= 1.4.2
- gettext >= 0.12.1
- make >= 3.79
- makeinfo (texinfo)
- tar
- bunzip2 (bzip2)
- gunzip (gzip)
- patch
- infocmp (ncurses-bin / ncurses-devel)
- gcc 2.95 or >= 3.0
- g++ 2.95 or >= 3.0
- flex
- bison
- pkg-config
- wget
- libpng2 or libpng3 (DirectFB)

2) Entra en Linux como Administrador y teclea estos comandos en la consola.
Este es un procedimiento largo que puede tomar algunas horas.


Código:

--------------------------------------------------------------------------------
cd /
mkdir /dream
cd /dream
export CVS_RSH=ssh
cvs -d anoncvs@cvs.tuxbox.org:/cvs/tuxbox -z3 co -P -rdreambox .
cd cdk
chmod ugo+x prepare
./prepare dm7000
make checkout
make dreamboximage_root
make rebuild-flash
make flash-compress
--------------------------------------------------------------------------------
 
Este es un procedimiento estandar y puedes encontrar muchos tutoriales en la red para instalar Enigma1 cdk.
Una vez instalado el CDK estas preparado para continuar con este tutorialy compilar las aplicaciones de ejemplo suministradas.
Solo debes crear un directorio como el del ejemplo:
mkdir mydevel
y copiar alli las fuentes que quieras compilar.
Para compilar una fuente de ejemplo solo debes ir a ese directorioy teclear el comando:
make

Para comprobar un codigo compilado solo lo debes cargar en tu Dreambox en el directorio /var/tuxbox/plugins
Los archivos:
Bibledemo.so
Bibledemo.cfg
 
Vision de la estructura de la aplicación
/*
+--------------------------------------------------------------------------
| La Biblia Enigma1 Tutorial
| ========================================
| Por: Bacicciosat aka Meo aka Luponero
| Traduccion: Nesi_tor
|
| Tutorial de entorno de la APIS de Enigma1 con codigo fuentes y comentarios
| (c) august 2006 by Meo
|
+---------------------------------------------------------------------------
*/

Atencion: No puedes modificar, redistribuir o publicar este tutorial en otro sitio sin la cabecera ni los creditos de Bacicciosat.

2. Vision de la estructura de la aplicación

Aplicaciones Enigma usando lenguaje C++.
Aplicaciones Enigma que puedes arrancar en tu Dreambox como extensiones llamadas plugins.

Cada plugin se compone de:
1) un archivo .cfg (archivo de texto simple)
2) un archivo .so compilado y ejecutable (la aplicacion real)
Atencion: Estos archivos necesitan tener el mismo nombre. La diferencia solo esta en la extension del archivo.
Por ejemplo: demo.so y demo.cfg

----------------


1) Sobre el archivo .cfg:

El archivo .cfg contiene informacion sobre nuestra aplicacion.
Es un archivo estandar .cfg que se usa para nuestros ejemplos.
La unica parte del archivo .cfg que necesitas modificar es la linea "name".
Esta linea contiene el nombre de tu aplicacion que sera el que se muestre en la lista de Plugins Dreambox.
Code:


Código:

--------------------------------------------------------------------------------
name=Demo Enigma Bible
desc=
depend=
type=2
needfb=0
needrc=0
needlcd=0
enigmaplugin=1
--------------------------------------------------------------------------------
 

2) Sobre el archivo .so :

El archivo .so es la aplicacion real. Es el codigo fuente compilado.
El archivo fuente es un archivo C++ y tiene una extension .cpp.
Cuando compiles el archivo fuente tendras el arhivo .so que podras cargar en tu Dreambox.
Pero, para crear una nueva aplicacion Enigma (plugin) necesitamos un archivo .cfg, un archivo .ccp y un makefile para compilar el archivo de codigo fuente .cpp.
Todos estos archivo estan suministrador en este tutorial. Puedes estudiar, modificar y compilar aplicaciones Enigma usando estos archivos de demostracion.


3) Vista de la aplicacion de codigo fuente:
Como se describe a continuacion nuestra aplicacion esta contenida en un archivo fuente (.cpp) que compliremos para obtener el archivo .so.
Este archivo fuente es un archivo fuente C++ normal que contiene la librerias de C y C++ y las librerias y APIS Enigma.
Para ilustrar un archivo fuente Enigma lo podemos dividir en 4 secciones principales:
a) Archivos include (librerias que necesita nuestro codigo. Podemos usar: librerias C,librerias C++, librerias Enigma, ...)
b) Declaracion de funciones y clases (Tenemos que declaras las clases y las funciones que usaremos en nuestro codigo)
c)El punto de entrada de la aplicacion (La funcion de Enigma que llama a iniciar la ejecucion de nuestra aplicacion)
d) El codigo (Lllamaremos las APIS Enigma y las funciones en codigo C++ normal para administrar los objetos graficos Enigma).

OK ya estamos preparados para crear nuestra primera aplicacion Enigma.
« Última modificación: 10/06/2008, 23:25 por elgeneral »
06/05/2008, 20:28 -

Re: Enigma 1, la biblia en español

#1
Registrado:
17/01/2008
Gracias:
140/2100
Mensajes
20506
Leccion 1: Ventana Hola Mundo
/*
+--------------------------------------------------------------------------
| La Biblia Enigma1 Tutorial
| ========================================
| Por: Bacicciosat aka Meo aka Luponero
| Traduccion: Nesi_tor
|
| Tutorial de entorno de la APIS de Enigma1 con codigo fuentes y comentarios
| (c) august 2006 by Meo
|
+---------------------------------------------------------------------------
*/

Leccion 1: Ventana Hola Mundo

Puedes encontrar en el adjunto:
- El archivo cfg (Bibledemo.cfg)
- El plugin compilado y funcionando (Bibledemo.so)
- El archivo de coigo fuente (bibledemo.cpp)
- El makefile (nedeed to compile code if you want to modify source)

OK esta es la primera leccion.
Vamos a crear una aplicacion Enigma (un plugin) que se mostrara en tu dreambox una simple ventana que muestre el mensaje "Hola Mundo".
Puedes ver un ejemplo en la captura de pantalla.

Puedes probar la aplicacion subiendo en tu dreambox (/var/tuxbox/plugins) los archivos que puedes encontrar en el adjunto: Bibledemo.cfg y Bibledemo.so

Puedes modificar esta aplicacion editando el archivo fuente bibledemo.cpp y recompilandolo para obtener un nuevo archivo Bibledemo.so.

El API Enigma nos explica en esta leccion la creacion de la ventana.
Esta es la principal Api sobre la creacion de la ventana:


Código:

--------------------------------------------------------------------------------
// crear ventana
eWindow(int takefocus=0);
// destruir ventana
~eWindow();
// ajustar ventana de titulo
setText(eString string);
// posicionado
cmove(ePoint(x, y));
// dimensionado
cresize(eSize(x, y));
--------------------------------------------------------------------------------
 
OK ya hemos listado la API principal, ya podemos escribir el codigo.
En esta primera leccion mostraremos todo el codigo comentando linea por linea.

Empezamos.

bibledemo.cpp:

Antes de todo tenemos que incluir todas las librerias que necesitamos para nuestra aplicacion (en este caso necesitamos: la libreria de plugin Enigma, la libreria standar C, la libreria de ventana Enigma para crear las ventana y la libreria de etiquetas Enigma para insertar un texto en una etiqueta) :


Código:

--------------------------------------------------------------------------------
#include <plugin.h>
#include <stdio.h>
#include <lib/gui/ewindow.h>
#include <lib/gui/elabel.h>
--------------------------------------------------------------------------------
 
OK ahora tenemos que declarar las clases que usaremos en nuestra aplicacion:


Código:

--------------------------------------------------------------------------------
// La declaracion de clase de nuestra principal ventana
class eBibleMainWindow: public eWindow
{
        // la etiqueta para mostrar el texto
        eLabel *label;
public:
                // el constructor.
        eBibleMainWindow();
                // el destructor.
        ~eBibleMainWindow();
};
--------------------------------------------------------------------------------
 
Perfecto !! ahora tenemos que añadir la funcion que Enigma llame a ejecutar nuestra aplicacion. El "punto de entrada".


Código:

--------------------------------------------------------------------------------
// El plugin punto de entrada, aqui empieza la ejecucion del codigo
extern "C" int plugin_exec( PluginParam *par )
{
        // nuestra instancia de dialogo de ejemplo.
        eBibleMainWindow dlg;
                // muestra el dialogo...
        dlg.show();
                // da el control el dialogo.. (el dialogo es modal!)
        int result=dlg.exec();
                // y despues de eso la ocultamos otra vez.
        dlg.hide();
        return result;
}
--------------------------------------------------------------------------------
 
La ejecucion del codigo ha empezado. ahora ya podemos añadir el codigo para crear nuestra ventana y mostrar nuestro mensaje "Hola mundo".
En este codigo nosotros:
1) Crearemos nuestra ventana principal
2) Daremos a nuestra ventana una posicion en la pantalla
3) daremos a nuestra ventana las dimensiones X e Y
4) Fijaremos el titulo de la ventana
5) Crearemos una etiqueta para mostrar nuestro mensaje
6) Daremos a la etiqueta una posicion y una dimension
7) Insertaremos un mensaje en la etiqueta


Código:

--------------------------------------------------------------------------------
eBibleMainWindow::eBibleMainWindow(): eWindow(1)
{
                // movemos el dialogo a 100.100...
        cmove(ePoint(100, 100));
                // ...y le damos dimensiones X e Y.
        cresize(eSize(520, 376));
                // fijamos el titulo.
        setText("Biblia Enigma Leccion 1: Ventana");
       
        // creamos la etiqueta para mostrar un texto.
        label=new eLabel(this);
        // le damos una posicion
        label->move(ePoint(50, 50));
        // fijamos las dimensiones de la etiqueta
        label->resize(eSize(200, 100));
        // asignamos el texto de la etiqueta
        label->setText("Hola Mundo !!");
}
--------------------------------------------------------------------------------
 
Finalmente solo tenemos que añadir una funcion automatica para destruccion de la ventana. No tenemos que hacer nada mas. Solo añadir la funcion estandar y automatica:


Código:

--------------------------------------------------------------------------------
eBibleMainWindow::~eBibleMainWindow()
{
        // No tenemos que hacer nada aqui. todos los objetos seran borrados automaticamente
}
--------------------------------------------------------------------------------
 
Como puedes ver es muy simple.
Ya puedes practicar la compilacion del codigo fuente que encontraras en el paquete adjunto y modificarlo.

Ejercicios:
- Cambiar el titulo de la ventana
- Cambiar la posicion y las dimensiones de la ventana
- Cambiar la posicion de la etiqueta dentro de la ventana


Esto es todo, y esta es la captura de la aplicacion y el pack completo.
(Continuara en la leccion 2 ... )

No tienes permiso para ver los enlaces. Regístrate o Autentícate
« Última modificación: 10/06/2008, 23:26 por elgeneral »
06/05/2008, 20:30 -

leccion 2

#2
Registrado:
17/01/2008
Gracias:
140/2100
Mensajes
20506
Leccion2: Botones
/*
+--------------------------------------------------------------------------
| La Biblia Enigma1 Tutorial
| ========================================
| Por: Bacicciosat aka Meo aka Luponero
| Traduccion: Nesi_tor
|
| Tutorial de entorno de la APIS de Enigma1 con codigo fuentes y comentarios
| (c) august 2006 by Meo
|
+---------------------------------------------------------------------------
*/

Leccion2: Botones

En el adjunto puedes encontrar:
- el archivo cfg (Bibledemo.cfg)
- El plugin compilado y funcional (Bibledemo.so)
- El archivo de codigo fuente (bibledemo.cpp)
- El makefile (necesario para compilar codigo si quieres modificar el codigo fuente)

OK esta es la segnda leccion.
Añadiremos a nuestra ventana un boton para salir de la aplicacion.
Puedes ver el ejemplo en la captura de pantalla.

Puedes probar la aplicacion simplemente subiendola a tu dreambox (/var/tuxbox/plugins) los archivos que puedes encontar en el adjunto: Bibledemo.cfg y Bibledemo.so

Puedes modificar la aplicacion editando el archivo de codigo fuente bibledemo.cpp y recompilarlo para tener un nuevo archivo Bibledemo.so.

La API Enigma que queremos explicar en esta leccion es la de creacion de un boton.
Esta es la Api principal sobre la creacion y administracion de botones:


Código:

--------------------------------------------------------------------------------
// crear boton
eButton(eWidget *parent);
// fijar el texto del boton
setText(eString string);
// posicionamiento
move(ePoint(x, y));
// dimensiones
resize(eSize(x, y));
// fijar shortcut y pixmap
setShortcut(int color);
setShortcutPixmap(int pixmap);
// decorar con un marco
loadDeco();
// funcion a llamar cuando se pulse el boton
CONNECT(eButton->selected, function);
--------------------------------------------------------------------------------
 
OK ahora hemos listado la API principal, ya podemos escribir el codigo.
Puedes encontrar el codigo de la aplicacion completa en el paquete adjunto
(bibledemo.cpp). Aqui solo comentare el codigo añadido en esta leccion.

Empecemos.

bibledemo.cpp añadidos:

Antes de nada tenemos que añadir los archivos a incluir de la libreria de botones Enigma:


Código:

--------------------------------------------------------------------------------
#include <lib/gui/ebutton.h>
--------------------------------------------------------------------------------
 
OK ahora tenemos que añadir el boton en nuestra clase principal. Esta es la nueva declaracion de clases:


Código:

--------------------------------------------------------------------------------
// La declaracion de clases de nuestra ventana principal
class eBibleMainWindow: public eWindow
{
// La etiqueta para mostrar el texto
eLabel *label;
// El boton
eButton *ok;
public:
// el constructor.
eBibleMainWindow();
// el destructor.
~eBibleMainWindow();
};
--------------------------------------------------------------------------------
 
Perfecto !! Ahora tenemos que añadir el boton en nuestro codigo principal de la funcion.
Esta es nuestra nueva funcion principal:


Código:

--------------------------------------------------------------------------------
eBibleMainWindow::eBibleMainWindow(): eWindow(1)
{
                // mover nuestro dialogo a 100.100...
        cmove(ePoint(100, 100));
                // ...y dar dimensiones X e Y.
        cresize(eSize(520, 376));
                // Fijar un titulo.
        setText("Biblia Enigma Leccion 2: Boton");
       
        // crear una etiqueta para mostrar el texto.
        label=new eLabel(this);
        // asignarle una posicion
        label->move(ePoint(50, 50));
        // fijar las dimensiones de la etiqueta
        label->resize(eSize(200, 100));
        // fijar el texto de la etiqueta
        label->setText("Push button to exit !!");

        // crear el boton
        ok = new eButton(this);
        // fijar el texto del boton
        ok->setText("Exit");
        // fijar una posicion
        ok->move(ePoint((clientrect.width() - 90)/2, clientrect.height() - 60));
        // fijar un tamaño
        ok->resize(eSize(90, 40));
        // fijar el shortcut y pixmap
        ok->setShortcut("green");
        ok->setShortcutPixmap("green");
        // decorar con un marco
        ok->loadDeco();
        // funcion a llamar cuando se pulse el boton
    CONNECT(ok->selected, eWidget::accept);
        // fijar el foco al boton
        setFocus(ok);

}
--------------------------------------------------------------------------------
 
Como puedes ver es muy sencillo.
Ya puedes practicar la compilacion de codigo fuente que podras encontrar en el paquete adjunto y modificarlo.

Ejercicios:
- Cambiar el texto del boton, el shortcut y la posicion
- Añadir otro boton

Esto es todo, y esta es la captura de la aplicacion y el paquete completo.
(Continuara en la leccion 3 ... )

No tienes permiso para ver los enlaces. Regístrate o Autentícate
« Última modificación: 10/06/2008, 23:27 por elgeneral »
06/05/2008, 20:33 -

Re: Enigma 1, la biblia en español

#3
Registrado:
17/01/2008
Gracias:
140/2100
Mensajes
20506
Leccion 3: MessageBox (Mensaje emergente)
/*
+--------------------------------------------------------------------------
| La Biblia Enigma1 Tutorial
| ========================================
| Por: Bacicciosat aka Meo aka Luponero
| Traduccion: Nesi_tor
|
| Tutorial de entorno de la APIS de Enigma1 con codigo fuentes y comentarios
| (c) august 2006 by Meo
|
+---------------------------------------------------------------------------
*/

Leccion 3: MessageBox (Mensaje emergente)

En el adjunto puedes encontrar:
- el archivo cfg (Bibledemo.cfg)
- El plugin compilado y funcional (Bibledemo.so)
- El archivo de codigo fuente (bibledemo.cpp)
- El makefile (necesario para compilar codigo si quieres modificar el codigo fuente)

Ok esta es la tercera leccion.
Añadiremos a nuestra ventana 2 botones para llamar a diferentes mensajes.
Puedes ver un ejemplo en la captura de pantalla.

Puedes probar la aplicacion simplemente subiendola a tu dreambox (/var/tuxbox/plugins) los archivos que puedes encontar en el adjunto: Bibledemo.cfg y Bibledemo.so

Puedes modificar la aplicacion editando el archivo de codigo fuente bibledemo.cpp y recompilarlo para tener un nuevo archivo Bibledemo.so.

La API Enigma que explicaremos en esta lección es la creacion de un messagebox (Mensaje emergente)API we will explain in this lesson is the messaagebox creation.
Esta es la principal API sobre la creacion y manejo de messagebox:


Código:

--------------------------------------------------------------------------------
// crear messagebox
eMessageBox(eString string, eString caption, int flags=btOK, int def=btOK, int timeout=0 );
// Flag: Botones
btOK=1, btCancel=2, btYes=4, btNo=8, btMax
// Flag : Iconos
iconInfo=16, iconWarning=32, iconQuestion=64, iconError=128
// Funciones:
show();
exec();
hide();
--------------------------------------------------------------------------------
 
OK ahora hemos listado la API principal, ya podemos escribir el codigo.
Puedes encontrar el codigo de la aplicacion completa en el paquete adjunto
(bibledemo.cpp). Aqui solo comentare el codigo añadido en esta leccion.

Empecemos!

Codigo añadido a bibledemo.cpp:

Antes de nada tenemos que añadir nuestros archivos de librerias Enigma de messagebox con un include:


Código:

--------------------------------------------------------------------------------
#include <lib/gui/emessage.h>
--------------------------------------------------------------------------------
 
Ok ahora tenemos que añadir dos funciones a nuestra clase principal:
void message1();
void message2();
Tenemos que encadenar nuestras dos funciones a las pulsaciones de cada boton.
De esta manera cuando un boton sea pulsado una de esta funciones sera llamada y mostrara un messagebox.
Esta es la nueva declaracion principal de clases:


Código:

--------------------------------------------------------------------------------
// La declaracion de clases de nuestra ventana principal
class eBibleMainWindow: public eWindow
{
        // la etiqueta para mostrar el texto
        eLabel *label;
        // la funcion a llamar cuando la boton 1 se pulse
        void message1();
        // la funcion a llamar cuando la boton 2 se pulse
        void message2();
public:
                // el constructor.
        eBibleMainWindow();
                // el destructor.
        ~eBibleMainWindow();
};
--------------------------------------------------------------------------------
 
Perfecto !! Ahora tenemos que añadir estos 2 botones en nuestro codigo principal de la funcion para llamar a las funciones que haran que se muestren los messagebox.
Esta es nuestra nueva funcion principal:


Código:

--------------------------------------------------------------------------------
eBibleMainWindow::eBibleMainWindow(): eWindow(1)
{
                // movemos nuestro dialogo a 100.100...
        cmove(ePoint(100, 100));
                // ...y le damos dimensiones X e Y.
        cresize(eSize(520, 376));
                // fijamos el titulo.
        setText("Biblia Enigma Leccion 3: MessageBox");
       
        // crear una etiqueta para mostrar el texto.
        label=new eLabel(this);
        // darle una posicion
        label->move(ePoint(20, 50));
        // fijar las dimensiones de la etiqueta
        label->resize(eSize(400, 100));
        // fijar el texto de la etiqueta
        label->setText("Pulsa un boton para mostrar un MessageBox");

        // Crear los botones y fijar las propiedades
        eButton * ok = new eButton(this);
        ok->setText("Simple");
        ok->move(ePoint((clientrect.width() - 200)/2, clientrect.height() - 60));
        ok->resize(eSize(90, 40));
        ok->loadDeco();
        // funciona a llamar cuando se presione el boton 1
    CONNECT(ok->selected, eBibleMainWindow::message1);

        eButton * ok2 = new eButton(this);
        ok2->setText("Salir");
        ok2->move(ePoint((clientrect.width())/2, clientrect.height() - 60));
        ok2->resize(eSize(90, 40));
        ok2->loadDeco();
        // funciona a llamar cuando se presione el boton 2
    CONNECT(ok2->selected, eBibleMainWindow::message2);
        // fijar el foco en el boton 1
        setFocus(ok);

}
--------------------------------------------------------------------------------
 
Ok ahora tenemos que añadir la funcion que mostrara el primer MessageBox (Messagebox simple con solo un boton):


Código:

--------------------------------------------------------------------------------
void eBibleMainWindow::message1()
{
        // crear messagebox
        eMessageBox msg("Hola por Nesitor :-)", "Info", eMessageBox::iconInfo|eMessageBox::btOK);
                // muestralo
                msg.show();
                // ejecuta
                msg.exec();
                // ocultar despues de la ejecucion (boton pulsado)
                msg.hide();
}
--------------------------------------------------------------------------------
 
Finalmente tenemos que añadir la funcion que mostrara el segundo MessageBox (Messagebox modal con dos botones):


Código:

--------------------------------------------------------------------------------
void eBibleMainWindow::message2()
{
        // crear messagebox (dos botones si/no)
        eMessageBox box("Quieres salir de la aplicacion?", "Pregunta", eMessageBox::btYes|eMessageBox::btNo|eMessageBox::iconQuestion, eMessageBox::btYes);
        // Muestralo
        box.show();
        // Ejecuta el codigo y guarda el resultado en la variable boton (boton pulsado)
        int button = box.exec();
        // ocultar despues de ja ejecucion
        box.hide();
        // Salir si se ha pulsado el boton si.
        if (button == eMessageBox::btYes)
        {
                eWidget::accept();
        }
}
--------------------------------------------------------------------------------
 

Como puedes ver es muy simple.
Ya puedes practicar la compilacion de codigo fuente que podras encontrar en el paquete adjunto y modificarlo.

Ejercicios:
- Cambia los textos e iconos de los botones de los MessageBox
- Añadir otro Messagebox

Esto es todo, y esta es la captura de la aplicacion y el paquete completo.
(Continuara en la leccion 4 ... )
No tienes permiso para ver los enlaces. Regístrate o Autentícate


valorar el esfuerzo y el trabajo de nesi_tor una obra de arte en español asi como el amplie las lecciones las colgare aki

saludos y gracias nesi_tor
« Última modificación: 10/06/2008, 23:29 por elgeneral »
06/05/2008, 20:57 -

Re: Enigma 1, la biblia en español

#4
Registrado:
26/01/2008
Gracias:
1/525
Mensajes
7406
Una maravilla amigo.

Enigma 1, la biblia en español-http://www.training24.net/riesgos/img/imgres/acuerdo.gif
07/05/2008, 22:13 -

Leccion 4: Entrada de texto

#5
Registrado:
17/01/2008
Gracias:
140/2100
Mensajes
20506
Leccion 4: Entrada de texto
/*
+--------------------------------------------------------------------------
| La Biblia Enigma1 Tutorial
| ========================================
| Por: Bacicciosat aka Meo aka Luponero
| Traduccion: Nesi_tor
|
| Tutorial de entorno de la APIS de Enigma1 con codigo fuentes y comentarios
| (c) august 2006 by Meo
|
+---------------------------------------------------------------------------
*/

Leccion 4: Entrada de texto

En el adjunto puedes encontrar:
- el archivo cfg (Bibledemo.cfg)
- El plugin compilado y funcional (Bibledemo.so)
- El archivo de codigo fuente (bibledemo.cpp)
- El makefile (necesario para compilar codigo si quieres modificar el codigo fuente)

Ok esta el la leccion 4.
Añadiremos a nuestra ventana una entrada de texto y un messagebox para mostrar el texto que tecleemos en la entrada de texto.
Puedes ver un ejemplo en la captura de pantalla.

Puedes probar la aplicacion simplemente subiendola a tu dreambox (/var/tuxbox/plugins) los archivos que puedes encontar en el adjunto: Bibledemo.cfg y Bibledemo.so

Puedes modificar la aplicacion editando el archivo de codigo fuente bibledemo.cpp y recompilarlo para tener un nuevo archivo Bibledemo.so.

La API Enigma que explicaremos en esta leccion es la creacion de entradas de texto.
Esta es la API principal sobre la creacion y manejo de entradas de texto:


Código:

--------------------------------------------------------------------------------
// crear entrada de texto
eTextInputField( eWidget* parent, eLabel *descr=0, eTextInputFieldHelpWidget* hlp=0, const char *deco="eNumber" );
// funciones:
setText(eString);
setMaxChars( int i )
setUseableChars( const char* );
--------------------------------------------------------------------------------
 
OK ahora hemos listado la API principal, ya podemos escribir el codigo.
Puedes encontrar el codigo de la aplicacion completa en el paquete adjunto
(bibledemo.cpp). Aqui solo comentare el codigo añadido en esta leccion.

Empecemos!

Codigo añadido a bibledemo.cpp:

Antes de nada tenemos que añadir nuestros archivos de librerias Enigma de entrada de textos:


Código:

--------------------------------------------------------------------------------
#include <lib/gui/textinput.h>
--------------------------------------------------------------------------------
 
Ok Ahora tenemos que añadir la declaracion de la entrada de texto en nuestra clase principal.
Tenemos que añadir la siguiente funcion:
void message1();
Conectaremos la ejecucion de esta funcion al boton.
En este momento cuando el boton se pulse llamara a esta funcion y mostrara un messagebox con el texto que hayamos insertado.
Esta es la nueva declaracion principal de clases:


Código:

--------------------------------------------------------------------------------
// La declaracion de clases de nuestra ventana principal
class eBibleMainWindow: public eWindow
{
        // la etiqueta para mostrar el texto
        eLabel *label;
    // la entrada de texto
        eTextInputField *mytext;
        // funcion a ejecutar cuando se pulse el boton
        void message1();
public:
                // el constructor.
        eBibleMainWindow();
                // el destructor.
        ~eBibleMainWindow();
};
--------------------------------------------------------------------------------
 
Perfecto !! Ahora tenemos que añadir el boton en nuestra funcion principal del codigo para llamar a la funcion que mostrara el messagebox con el texto.
Esta es nuestra nueva funcion principal:


Código:

--------------------------------------------------------------------------------
eBibleMainWindow::eBibleMainWindow(): eWindow(1)
{
                // movemos nuestro dialogo a 100.100...
        cmove(ePoint(100, 100));
                // ...y le damos dimensiones X e Y.
        cresize(eSize(520, 376));
                // fijamos el titulo.
        setText("Enigma Bible Lesson 4: TextInput");
       
        // creamos una etiqueta para mostrar el texto.
        label=new eLabel(this);
        // lo posicionamos
        label->move(ePoint(20, 50));
        // fijamos las dimensiones de la etiqueta
        label->resize(eSize(400, 100));
        // fijamos el texto de la etiqueta
        label->setText("Push Ok Button and digit your text.");

        // crear entrada de texto
        mytext=new eTextInputField(this);
        // damos la posicion
        mytext->move(ePoint(20, 150));
        // damos el tamaño
        mytext->resize(eSize(400, 40));
        // fijamos el numero maximo de caracteres en 100
        mytext->setMaxChars(100);
        //mytext->setUseableChars("1234567890");
        //mytext->setText(codeentry);
        // mostramos un marco de decoracion
        mytext->loadDeco();

        // creamos botones y fijamos las propiedades
        eButton * ok = new eButton(this);
        ok->setText("Show");
        ok->move(ePoint((clientrect.width() - 90)/2, clientrect.height() - 60));
        ok->resize(eSize(100, 40));
        ok->setShortcut("green");
        ok->setShortcutPixmap("green");
        ok->loadDeco();
        // funcion a llamar cuando se pulse el boton
    CONNECT(ok->selected, eBibleMainWindow::message1);

        //fijamos el foco en la entrada de texto
        setFocus(mytext);

}
--------------------------------------------------------------------------------
 
Finalmente tenemos que añadir la funcion que mostrara el messagebox con el texto que hayamos introducido en la entrada de texto:


Código:

--------------------------------------------------------------------------------
void eBibleMainWindow::message1()
{
        // declaramos la variable que usaremos en esta funcion
        eString message, message2;
        // asignaremos al mensaje 2 el contenido de la entrada de texto
        message2 = mytext->getText();
        // Componer el mensaje encadenando strings(cadenas de caracteres)
        message = "Escribiste: " + message2;       

        // Crear, mostrar y ejecutar el messagebox para mostrar el mensaje
        eMessageBox msg((message), "Info", eMessageBox::iconInfo|eMessageBox::btOK);
                msg.show();
                msg.exec();
                msg.hide();
}
--------------------------------------------------------------------------------
 

Como puedes ver es muy simple.
Ya puedes practicar la compilacion de codigo fuente que podras encontrar en el paquete adjunto y modificarlo.

Ejercicios:
- Fijar un texto predeterminado en la entrada de texto
- Fijar los caracteres que admitira la entrada de texto
- Fijar el numero maximo de caracteres permitidosen la entrada de texto



Esto es todo, y esta es la captura de la aplicacion y el paquete completo.
(Continuara en la leccion 5 ... )

No tienes permiso para ver los enlaces. Regístrate o Autentícate
« Última modificación: 10/06/2008, 23:30 por elgeneral »
09/05/2008, 21:01 -

Leccion 5: Campo de chequeo

#6
Registrado:
17/01/2008
Gracias:
140/2100
Mensajes
20506
Leccion 5: Campo de chequeo
/*
+--------------------------------------------------------------------------
| La Biblia Enigma1 Tutorial
| ========================================
| Por: Bacicciosat aka Meo aka Luponero
| Traduccion: Nesi_tor
|
| Tutorial de entorno de la APIS de Enigma1 con codigo fuentes y comentarios
| (c) august 2006 by Meo
|
+---------------------------------------------------------------------------
*/

Leccion 5: Campo de chequeo

En el adjunto puedes encontrar:
- el archivo cfg (Bibledemo.cfg)
- El plugin compilado y funcional (Bibledemo.so)
- El archivo de codigo fuente (bibledemo.cpp)
- El makefile (necesario para compilar codigo si quieres modificar el codigo fuente)

Ok esta es la leccion 5.
Vamos a añadir a nuestra ventana un campo de chequeo y un messagebox para mostrar en un mensaje si el campo de chequeo esta activado o no.
Puedes ver un ejemplo en la captura de pantalla.

Puedes probar la aplicacion simplemente subiendola a tu dreambox (/var/tuxbox/plugins) los archivos que puedes encontar en el adjunto: Bibledemo.cfg y Bibledemo.so

Puedes modificar la aplicacion editando el archivo de codigo fuente bibledemo.cpp y recompilarlo para tener un nuevo archivo Bibledemo.so.

La API Enigma que explicaremos en esta leccion es la creacion de checkbox(campos de chequeo).
Esta es la principal API sobre la creacion y uso de checkbox:


Código:

--------------------------------------------------------------------------------
// create Checkbox
eCheckbox(eWidget *parent, int checked=0, int takefocus=1, bool swapTxtPixmap=false, const char *deco="eCheckBox" );
// Funciones:
setCheck(int c);
int isChecked() { return ischecked; }
--------------------------------------------------------------------------------
 
OK ahora hemos listado la API principal, ya podemos escribir el codigo.
Puedes encontrar el codigo de la aplicacion completa en el paquete adjunto
(bibledemo.cpp). Aqui solo comentare el codigo añadido en esta leccion.

Empecemos!

Codigo añadido a bibledemo.cpp:

Antes de nada teneños que añadir con un include las librerias de Checkbox Enigma:


Código:

--------------------------------------------------------------------------------
#include <lib/gui/echeckbox.h>
--------------------------------------------------------------------------------
 
Ok ahora tenemos que añadir la declaracion de checkbox en nuestra clase principal.
Tenemos que añadir la siguiente funcion:
void message1();
Conectaremos la ejecucion de esta funcion al boton.
En el momento que el boton sea pulsado esta funcion sera llamada y se mostrara un messagebox con el resultado.
Esta es la nueva declaracion principal de clases:


Código:

--------------------------------------------------------------------------------
// La declaracion de clases de nuestra ventana principal
class eBibleMainWindow: public eWindow
{
        // la etiqueta para mostrar el texto
        eLabel *label;
    // el Checkbox
        eCheckbox *mycheck;
        // funcion a ejecutar cuando se pulse el boton
        void message1();
public:
                // el constructor.
        eBibleMainWindow();
                // el destructor.
        ~eBibleMainWindow();
};
--------------------------------------------------------------------------------
 
Perfecto !! Ahora tenemos que añadir el checkbox y el boton en nuestro codigo principal para llamar a la funcion que mostrara el messagebox con el resultado.
Esta es nuestra nueva funcion principal:


Código:

--------------------------------------------------------------------------------
eBibleMainWindow::eBibleMainWindow(): eWindow(1)
{
                // movemos nuestro dialogo a 100.100...
        cmove(ePoint(100, 100));
                // ...y le damos dimensiones X e Y.
        cresize(eSize(520, 376));
                // fijamos el titulo.
        setText("Biblia Enigma Leccion 5: CheckBox");
        // Crear checkbox
        mycheck=new eCheckbox(this, 1);
        // asignar posicion
        mycheck->move(ePoint(10, 200));
        // asignar dimensiones (x e y)
        mycheck->resize(eSize(clientrect.width() - 20, 50));
        // Texto a mostrar sobre el checkbox
        mycheck->setText("Marcado / Desmarcado");

        // crear boton y fijar las propiedades
        eButton * ok = new eButton(this);
        ok->setText("Mostrar");
        ok->move(ePoint((clientrect.width() - 90)/2, clientrect.height() - 60));
        ok->resize(eSize(100, 40));
        ok->setShortcut("green");
        ok->setShortcutPixmap("green");
        ok->loadDeco();
        // funcion a llamar cuando el boton se pulse
    CONNECT(ok->selected, eBibleMainWindow::message1);

        //fijar el foco en el checkbox
        setFocus(mycheck);

}
--------------------------------------------------------------------------------
 
Finalmente tenemos que añadir la funcion que mostrara el MessageBox con el resultado:


Código:

--------------------------------------------------------------------------------
void eBibleMainWindow::message1()
{
        // Declarar variable que usaremos en esta funcion
        eString message;
        // Asignar mensaje a la variable
        message = "El Checkbox esta Marcado";
        // Asignar otro mensaje en el caso de que el checkbox este marcado
        if (mycheck->isChecked()) {
                message = "El Checkbox esta Desmarcado";
        }
        // Crear, mostrar y ejecutar el messagebox para mostrar el mensaje
        eMessageBox msg((message), "Info", eMessageBox::iconInfo|eMessageBox::btOK);
                msg.show();
                msg.exec();
                msg.hide();
}
--------------------------------------------------------------------------------
 

Como puedes ver es muy simple.
Ya puedes practicar la compilacion de codigo fuente que podras encontrar en el paquete adjunto y modificarlo.

Ejercicios:
- Fijar el estado predeterminado del checkbox como desmarcado


Esto es todo, y esta es la captura de la aplicacion y el paquete completo.
(Continuara en la leccion 6 ... )

No tienes permiso para ver los enlaces. Regístrate o Autentícate
« Última modificación: 10/06/2008, 23:32 por elgeneral »
10/05/2008, 16:30 -

Leccion 6: Campo de lista

#7
Registrado:
17/01/2008
Gracias:
140/2100
Mensajes
20506
Leccion 6: Campo de lista

En el adjunto puedes encontrar:
- el archivo cfg (Bibledemo.cfg)
- El plugin compilado y funcional (Bibledemo.so)
- El archivo de codigo fuente (bibledemo.cpp)
- El makefile (necesario para compilar codigo si quieres modificar el codigo fuente)

Ok esta es la leccion 6.
Añadiremos a nuestra ventana un campo de lista y un messagebox para mostrar el objeto de la lista que hayamos seleccionado.
Puedes ver un ejemplo en la captura de pantalla.

Puedes probar la aplicacion simplemente subiendola a tu dreambox (/var/tuxbox/plugins) los archivos que puedes encontar en el adjunto: Bibledemo.cfg y Bibledemo.so

Puedes modificar la aplicacion editando el archivo de codigo fuente bibledemo.cpp y recompilarlo para tener un nuevo archivo Bibledemo.so.

La API Enigma que explicaremos en esta leccion es la creacion del campo de lista.
Esto es solo una parte de la API de campo de lista. El campo de lista es mas complicado, asi que solo examinare aqui las llamadas principales:


Código:

--------------------------------------------------------------------------------
// crear un campo de lista
eListBoxEntry(eListBox<eListBoxEntry>* parent, eString hlptxt=0, int selectable=3 );
// Funciones:
selectedItem(eListBoxEntryText *item);
selectionChanged(eListBoxEntryText *item);
setColumns(int);
beginAtomic();
clearList();
endAtomic();

// objetos del campo de lista:
//create new item:
eListBoxEntryText(eListBox<eListBoxEntryText>* lb, const char* txt=0, void ****=0, int align=0, const eString &hlptxt="", int ***type = value );
// obtener objeto seleccionado
item->getText();
// obtener *** seleccionado
item->get***()
--------------------------------------------------------------------------------
 
OK ahora hemos listado la API principal, ya podemos escribir el codigo.
Puedes encontrar el codigo de la aplicacion completa en el paquete adjunto
(bibledemo.cpp). Aqui solo comentare el codigo añadido en esta leccion.

Empecemos!

Codigo añadido a bibledemo.cpp:

Antes de nada teneños que añadir con un include las librerias de Checkbox Enigma:


Código:

--------------------------------------------------------------------------------
#include <lib/gui/listbox.h>
--------------------------------------------------------------------------------
 
Ok ahora tienes que añadir la declaracion de los campos de lista en tu clase principal.
Tenemos que añair la siguiente funcion:
void message1();
Tenemos que conectar la ejecucion de esta funcion a la seleccion del campo de lista.
De la siguiente manera cuando seleccionemos un objeto esta funcion sera llamada y se mostrara el objeto del campo de lista seleccionado.
Esta es la nueva declaracion principal de clases:


Código:

--------------------------------------------------------------------------------
// La declaracion de clases de nuestra ventana principal
class eBibleMainWindow: public eWindow
{
        // la etiqueta para mostrar el texto
        eLabel *label;
    // el campo de lista
        eListBox<eListBoxEntryText> *theList;
        // funcion a ejecutar cuando se seleccione un objeto
        void message1(eListBoxEntryText *item);
public:
                // el constructor.
        eBibleMainWindow();
                // el destructor.
        ~eBibleMainWindow();
};
--------------------------------------------------------------------------------
 
Perfecto !! Ahora tenemos que añadir el campo de lista y asociarlo con los objetos. Solo tendremos que conectar el campo de lista
a la funcion que sera llamada cuando el objeto se seleccione:


Código:

--------------------------------------------------------------------------------
eBibleMainWindow::eBibleMainWindow(): eWindow(1)
{
                // mover nuestro dialogo a 100.100...
        cmove(ePoint(100, 100));
                // ...y dar dimensiones X e Y.
        cresize(eSize(520, 376));
                // fijar un titulo.
        setText("Biblia Enigma Leccion 6: Campo de lista");
       
        // crear una etiqueta para mostrar un texto.
        label=new eLabel(this);
        // posicionarlo
        label->move(ePoint(10, 10));
        // fijar las dimensiones de la etiqueta
        label->resize(eSize(400, 60));
        // fijar la etiqueta del texto
        label->setText("Cual es tu imagen de Dreambox favorita ?");

        // Crear un campo de lista
        theList = new eListBox<eListBoxEntryText>(this);
        // darle una posicion
        theList->move(ePoint(10, 100));
        // fijar dimensiones
        theList->resize(eSize(clientrect.width() - 20, clientrect.height() - 160));
        // decorarla con un marco
        theList->loadDeco();
        // fijar numero de columnas
        theList->setColumns(1);
        // fijar los flags
        theList->beginAtomic();
        theList->clearList();
        // Rellenar el campo de lista con objetos
        new eListBoxEntryText(theList, "******", (void *) (1));
        new eListBoxEntryText(theList, "Colosseum", (void *) (2));
        new eListBoxEntryText(theList, "TD Team", (void *) (3));
        new eListBoxEntryText(theList, "KGD Team", (void *) (4));
        theList->endAtomic();
       
        // Funcion a llamar cuando un objeto se seleccione
        CONNECT(theList->selected, eBibleMainWindow::message1);

        // fijar el foco en la lista
        setFocus(theList);

}
--------------------------------------------------------------------------------
 
Finalmente tenemos que añadir la funcion que mostrara el MessageBox con el objeto seleccionado:


Código:

--------------------------------------------------------------------------------
void eBibleMainWindow::message1(eListBoxEntryText *item)
{
        // declarar variable que se usara en esta funcion
        eString message, message2;
        // asignar al mensaje 2 el texto del objeto seleccionado
        message2 = item->getText();
        // componer mensaje encadenando strings (cadenas de texto)
        message = "Tu imagen de Dreambox preferida es:\n " + message2;       
        // Crear, mostrar y ejecutar el messagebox para mostrar el mensaje
        eMessageBox msg((message), "Info", eMessageBox::iconInfo|eMessageBox::btOK);
                msg.show();
                msg.exec();
                msg.hide();
}
--------------------------------------------------------------------------------
 

Como puedes ver es muy simple.
Ya puedes practicar la compilacion de codigo fuente que podras encontrar en el paquete adjunto y modificarlo.

Ejercicios:
- Obtener el objeto *** e insertarlo en el texto del objeto
- Crear una etiqueta para mostrar el cambio de seleccion con la funcion: selectionChanged(eListBoxEntryText *item);


Esto es todo, y esta es la captura de la aplicacion y el paquete completo.
(Continuara en la leccion 7 ... )

No tienes permiso para ver los enlaces. Regístrate o Autentícate
« Última modificación: 10/06/2008, 23:33 por elgeneral »
17/05/2008, 17:37 -

Campo de Combo

#8
Registrado:
17/01/2008
Gracias:
140/2100
Mensajes
20506
Leccion7: Campo de Combo
/*
+--------------------------------------------------------------------------
| The Bible Enigma1 Tutorial
| ========================================
| By: Bacicciosat aka Meo aka Luponero
|
| Enigma 1 API GUI tutorial with Sources Code and Comments
| (c) august 2006 by Meo
|
+---------------------------------------------------------------------------
*/

Leccion7: Campo de Combo

En el adjunto puedes encontrar:
- el archivo cfg (Bibledemo.cfg)
- El plugin compilado y funcional (Bibledemo.so)
- El archivo de codigo fuente (bibledemo.cpp)
- El makefile (necesario para compilar codigo si quieres modificar el codigo fuente)

Ok esta es la leccion 7.
Añadiremos a nuestra ventana un campo de combo(Combobox) y un messagebox para mostrar el objeto de la lista que se haya seleccionado.
Puedes ver un ejemplo en la captura de pantalla.

Puedes probar la aplicacion simplemente subiendola a tu dreambox (/var/tuxbox/plugins) los archivos que puedes encontar en el adjunto: Bibledemo.cfg y Bibledemo.so

Puedes modificar la aplicacion editando el archivo de codigo fuente bibledemo.cpp y recompilarlo para tener un nuevo archivo Bibledemo.so.

La API Enigma que se explicara en esta leccion es la creacion de el Combobox.
ESta es solo una parte de la API de combobox. El Combobox es muy complicado y es un campo que contiene un listbox del cual solo se examinara aqui la funcion principal:


Código:
// crear Combobox
eComboBox(eWidget* parent, int OpenEntries=5, eLabel* desc=0, int takefocus=1, const char *deco="eComboBox" );
// funciones:
int setCurrent( int, bool=false );

// objetos de la Listbox:
//crear nuevo objeto new item:
eListBoxEntryText(eListBox<eListBoxEntryText>* lb, const char* txt=0, void ****=0, int align=0, const eString &hlptxt="", int ***type = value );
// obtener objeto seleccionado
getCurrent()->getText();
// obtener *** seleccionado
getCurrent()->get***()OK ahora hemos listado la API principal, ya podemos escribir el codigo.
Puedes encontrar el codigo de la aplicacion completa en el paquete adjunto
(bibledemo.cpp). Aqui solo comentare el codigo añadido en esta leccion.

Empecemos!

Codigo añadido a bibledemo.cpp:

Antes de nada teneños que añadir con un include las librerias de Combobox Enigma:


Código:
#include <lib/gui/combobox.h>Ok ahora tenemos que añadir la declaracion del Combobox en nuestra clase principal.
Tenemos que añadir la siguiente funcion:
void message1();
Tenemos que conectar la ejecucion de esta funcion a la seleccion del boton.
De la siguiente manera cuando seleccionemos un objeto esta funcion sera llamada i mostraremos el objeto del Combobox seleccionado.
Esta es la nueva declaracion principal de clases:


Código:
// La declaracion de clases de nuestra ventana principal
class eBibleMainWindow: public eWindow
{
   // la etiqueta para mostrar el texto
   eLabel *label;
   // el listbox
   eListBox<eListBoxEntryText> *theList;
    // el combobox
   eComboBox *Lang;
   // funcion a ejecutar cuando se pulse el boton
   void message1();
public:
      // el constructor.
   eBibleMainWindow();
      // el destructor.
   ~eBibleMainWindow();
};Perfecto !! ahora tenemos que añadir el Combobox y rellenar esto con objetos. Solo tenemos que añadir el boton y conectarlo
a la funcion que mostrara un messagebox:


Código:
eBibleMainWindow::eBibleMainWindow(): eWindow(1)
{
      // mover nuestro dialogo a 100.100...
   cmove(ePoint(100, 100));
      // ...y dar dimensiones X e Y.
   cresize(eSize(520, 376));
      // fijar un titulo.
   setText("Biblia Enigma Leccion 7: Combobox");
   
   // crear una etiqueta para mostrar el texto.
   label=new eLabel(this);
   // dar una posicion
   label->move(ePoint(50, 50));
   // fijar las dimensiones de la etiqueta
   label->resize(eSize(400, 60));
   // fijar el texto de la etiqueta
   label->setText("Selecciona tu lenguaje");

   // Crear el Combobox
   Lang=new eComboBox(this, 4);
   // Rellenar el Combobox con una lista de objetos
   new eListBoxEntryText(*Lang, "English", (void *) (0));
   new eListBoxEntryText(*Lang, "French", (void *) (1));
   new eListBoxEntryText(*Lang, "Italian", (void *) (2));
   new eListBoxEntryText(*Lang, "Dutch", (void *) (3));
   // Fijar posicion del Combobox
   Lang->move(ePoint(50, 160));
   // dimensiones del Combobox
   Lang->resize(eSize(clientrect.width()-120, 35));
   // fijar la entrada predeterminada del Combobox para el primer elemento de la lista
   Lang->setCurrent(0);
   // decorar el Combo con un marco
   Lang->loadDeco();
   
   // crear boton y fijar propiedades
   eButton * ok = new eButton(this);
   ok->setText("Mostrar");
   ok->move(ePoint((clientrect.width() - 90)/2, clientrect.height() - 60));
   ok->resize(eSize(100, 40));
   ok->setShortcut("green");
   ok->setShortcutPixmap("green");
   ok->loadDeco();
   
   // funcion a llamar cuando se pulse el boton
    CONNECT(ok->selected, eBibleMainWindow::message1);
   // fijar el foco en el Combobox
   setFocus(Lang);

}Finalmente tenemos que añadir la funcion que mostrar el messagebox con el objeto seleccionado:


Código:
void eBibleMainWindow::message1()
{
   // declarar una variable que se usara en esta funcion
   eString message, message2;
   // asignar el mensaje 2 para el objeto con el texto seleccionado
   message2 = Lang->getCurrent()->getText();
   // componer mensaje encadenando strings (cadenas de texto)
   message = "Tu Lenguaje es:\n " + message2;   
   // Crear, mostrar y ejecutar el messagebox para mostrar el mensaje
   eMessageBox msg((message), "Info", eMessageBox::iconInfo|eMessageBox::btOK);
      msg.show();
      msg.exec();
      msg.hide();
}
Como puedes ver es muy simple.
Ya puedes practicar la compilacion de codigo fuente que podras encontrar en el paquete adjunto y modificarlo.

Ejercicios:
- Obtener el texto del objeto *** dentro de la lista

Esto es todo, y esta es la captura de la aplicacion y el paquete completo.
(Continuara en la leccion 8 ... )

No tienes permiso para ver los enlaces. Regístrate o Autentícate
« Última modificación: 10/06/2008, 23:34 por elgeneral »
17/05/2008, 18:10 -

Re: Enigma 1, la biblia en español

#9
Registrado:
16/02/2008
Gracias:
2/18
Mensajes
299
buen aporte conpi , porcierto es normal que le llamen biblia es largo todo esto pero esa son las dream misterios y misterios
saludos y sigue hacin conpi
21/05/2008, 20:54 -

Leccion 8: Conexión y Descarga HTTP

#10
Registrado:
17/01/2008
Gracias:
140/2100
Mensajes
20506
Leccion 8: Conexión y Descarga HTTP

/*
+--------------------------------------------------------------------------
| La Biblia Enigma1 Tutorial
| ========================================
| Por: Bacicciosat aka Meo aka Luponero
| Traduccion: Nesi_tor
|
| Tutorial de entorno de la APIS de Enigma1 con codigo fuentes y comentarios
| (c) august 2006 by Meo
|
+---------------------------------------------------------------------------
*/

Leccion 8: Conexión y Descarga HTTP

Ok esta el la lección FINAL.
Vamos a crear una pequeña aplicación.
Este plugin conectara a la web de Wikipedia y descalrgara la pagina sobre el MKportal.

Si has seguido este tutorial eres capaz de entender el codigo y la API Enigma.
No lo explicare de nuevo.
Solo posteare aqui el codigo fuente comentado y completado.


Código:

--------------------------------------------------------------------------------

/*
+--------------------------------------------------------------------------
| La Biblia Enigma1 Tutorial
| ========================================
| Por: Bacicciosat aka Meo aka Luponero
| Traduccion: Nesi_tor
|
| Leccion 8: Conexión y Descarga HTTP
| (c) august 2006 by Meo
|
+---------------------------------------------------------------------------
*/

// incluimos los archivos que necesitaremos para nuestro codigo.
#include <stdio.h>
#include <stdlib.h>
#include <plugin.h>
#include <math.h>
#include <dirent.h>
#include <string.h>
#include <lib/gui/ewindow.h>
#include <lib/gui/ebutton.h>
#include <lib/gui/emessage.h>
#include <lib/gui/textinput.h>
#include <lib/gui/combobox.h>
#include <lib/gui/statusbar.h>
#include <lib/gui/eskin.h>
#include <lib/gdi/font.h>
#include <lib/gdi/epng.h>
#include <lib/gdi/gfbdc.h>
#include <lib/system/httpd.h>
#include <lib/gui/eprogress.h>
#include <upgrade.h>
#include <iostream>
#include <fstream>
#include <cstdio>
#include <lib/base/thread.h>
#include <lib/base/estring.h>


// La declaracion de la clase de nuestro sistema de conexión HTTP
class Fetcher : public Object
{       
        // El archivo temporal en el que guardaremos los datos descargados
        eString tempPath;
        // punteros y funciones internas de la conexion de descarga
        eHTTPConnection * connectionP;
        eHTTPDataSource * dataSinkP;
        void transferDone(int err);
        eHTTPDataSource * createDownloadSink(eHTTPConnection *conn);       
public:
        Signal1<void,int> downloadDone;
        void fetch();
};

// La declaracion de clases de nuestra ventana principal
class eBibleMainWindow: public eWindow
{
        // la etiqueta para mostrar el texto a mostrar
        eLabel *label;
        // el boton para iniciar la conexión
        eButton *ok;
        // el objeto de conexion
        Fetcher theFetcher;
        // un flag para indicar el estado de la descarga
        int downloadDoneFlag;
        int inDownloadFlag;
public:
                // el constructor.
        eBibleMainWindow();
        // funcion a llamar cuando se pulse el boton
        void Wconnect();
        // funcion a llamar cuando la descarga se complete.
        void downloadDone(int err);
                // el destructor.
        ~eBibleMainWindow();
};

// La definición de la funcion C que usaremos para borrar las etiquetas HTML del texto descargado
eString removeTags(eString in);
       
// El punto de entrada del plugin, Aqui empezara la ejecución del codigo
extern "C" int plugin_exec( PluginParam *par )
{
        // nuestra instancia del dialogo de demostracion.
        eBibleMainWindow dlg;
                // mostrar el dialogo...
        dlg.show();
                // dar el control al dialogo.. (el dialogo es modal!)
        int result=dlg.exec();
                // y despues de eso, esconderlo de nuevo.
        dlg.hide();
        return result;
}


eBibleMainWindow::eBibleMainWindow(): eWindow(1)
{
        inDownloadFlag = 0;
                // mover nuestro dialogo a 100.100...
        cmove(ePoint(100, 70));
                // ...darle dimensiones X e Y.
        cresize(eSize(520, 436));
                // fijar el titulo.
        setText("Biblia Enigma Leccion 8: Conexión HTTP");
       
        // crear una etiqueta para mostrar el texto.
        label=new eLabel(this);
        // darle una posición
        label->move(ePoint(10, 0));
        // fijar las dimensiones de la etiqueta
        label->resize(eSize(490, 380));
        // fijar el texto de la etiqueta
        label->setText("Esta es una conexion HTTP de demostacion. Conectaremos con la Web de Wikipedia y descargaremos la pagina sobre Mkportal que es un escrito de CMS y distribuido por Meo aka Bacicciosat. Parsearemos la web de Wikipedia y mostraremos en esta ventana la definicion de MKPortal de la Wikipedia.");
        // fijar el flag de estado a la etiqueta
        label->setFlags(RS_WRAP);

        // crear un boton y fijar las propiedades
        ok = new eButton(this);
        ok->setText("Conectar");
        ok->move(ePoint((clientrect.width() - 150)/2, clientrect.height() - 60));
        ok->resize(eSize(150, 40));
        ok->setShortcut("green");
        ok->setShortcutPixmap("green");
        ok->loadDeco();

        // funcion a llamar cuando se pulse el boton
    CONNECT(ok->selected, eBibleMainWindow::Wconnect);

}

void eBibleMainWindow::Wconnect()
{
        // Fijar el flag que indicara el estado de la descarga
        if(!inDownloadFlag) {       
                inDownloadFlag = 1;
                // Etiqueta oculta para cambiar el texto
                label->hide();
                // fijar nuevo texto para la etiqueta
                label->setText("Espera por favor, conexión a la web de Wikipedia en progreso...");
                // mostrar la etiqueta con el texto nuevo
                label->show();
                // Funcion a llamar cuando se complete la descarga
                CONNECT(theFetcher.downloadDone, eBibleMainWindow::downloadDone);
                // Fijar el flag que indicara que hay conexiones iniciadas
                downloadDoneFlag = 0;
                // Lamar a la funcion que iniciara la conexión HTTP
                theFetcher.fetch();
        }
}

void Fetcher::fetch()
{       
          // declarar una variable
        eString url;
        // asignar al la variable la URL a la que se quiere conectar
        url = "No tienes permiso para ver los enlaces. Regístrate o Autentícate";
        // asignar a la clase variable el archivo temporal que se usara para guardar los datos descargados
        tempPath = "/var/tmp/bdemo.tmp";
        // inicializar el control del flag de error
        int error = 0;
        // iniciar conexion
        connectionP = eHTTPConnection::doRequest(url.c_str(), eApp, &error);
        // Mostrar un Messagebox en caso ce error de conexion
        if(!connectionP || error)
        {        eMessageBox msg("Error descargando " + url + "(" + eString().sprintf("%d", error) + ")", _("Detalles"), eMessageBox::btOK);
                msg.show();    msg.exec();    msg.hide();
        }
        else
        {
                //si la conexion se ha establecido iniciar las funciones de descarga
                CONNECT(connectionP->transferDone, Fetcher::transferDone);
                CONNECT(connectionP->createDataSource, Fetcher::createDownloadSink);
                // fijar el nombre de user-agent
                connectionP->local_header["User-Agent"] = "PLBOT";
                connectionP->start();
        }
}

void Fetcher::transferDone(int err)
{       
        // Si no hay ningun error podemos llamar a la funcion de descarga completa
        if(!err)
        {        connectionP = NULL;
                // Decir que la descarga esta preparada
                /*emit*/ downloadDone(err);
        }
        else
        {
                //sino mostrar un Messagebox con la descripcion del error.
                eString sMsg = "Error " + eString().sprintf("%d", err);
                eMessageBox msg(sMsg, _("User Abort"), eMessageBox::iconWarning|eMessageBox::btOK);
                msg.show();    msg.exec();    msg.hide();
        }
}
// procedimiento de descarga interna (estandar)
eHTTPDataSource * Fetcher::createDownloadSink(eHTTPConnection *conn)
{        dataSinkP = new eHTTPDownload(connectionP, (char *)tempPath.c_str());

        return(dataSinkP);

}

void eBibleMainWindow::downloadDone(int err)
{
        // fijar el flag que indicara que la descarga se ha completado
        if(!downloadDoneFlag)
        {        downloadDoneFlag = 1;
                // crear un buffer para leer el archivo temporal con los datos descargados.
                char buf[512];
                // declarar las variables que se usaran en esta funcion
                eString strview, strview1;
                // abrir el archivo temporal que contiene los datos descargados
                  FILE *f = fopen("/var/tmp/bdemo.tmp", "rt");
                  if (f)
                  {
                        //Añadir una introduccion de texto
                        strview = "Mkportal CMS. Autor Meo aka Bacicciosat aka Luponero. No tienes permiso para ver los enlaces. Regístrate o Autentícaten\nWikipedia:\n";
                        // buscar la linea que se quiere (La definicion de Mkportal que hemos descargado de la web Wikipedia)
                        while (fgets(buf, 512, f))
                    {
                                if (strstr(buf, "is a free Portal"))
                                break;
                        }
                        // guardar esta linea en la variable
                        strview1 = eString(buf);
                        // borrar las etiquetas HTML
                        strview1 = removeTags(strview1);
                        //  encadenar strings para componer nuestro texto de salida
                        strview += strview1;
                        // leer las siguientes lineas .....
                      while (fgets(buf, 512, f))
                      {
                        // si hemos encontrado las strings con el final de la definicion ya podemos leer el archivo
                                if (strstr(buf, "See also"))
                                break;
                        // sino guardar la linea en la variable
                                strview1 = eString(buf);
                        // borrar las etiquetas HTML
                                strview1 = removeTags(strview1);
                        // encadenar strings para componer nuestro texto de salida
                                strview += strview1;
                      }
                        // cerrar archivo
                      fclose(f);
                  }
                //Borrar el archivo temporal que hemos usado para guardar los datos descargados
                  ::unlink("/var/tmp/bdemo.tmp");
                // Ocultar la etiqueta que cambia el texto
                label->hide();
                // Insertar en la etiqueta la salida que hemos guardad en la variable strview
                label->setText(strview);
                // Mostrar la etiqueta con el texto nuevo
                label->show();
                // ocultar el boton de conexion
                ok->hide();
                // fijar el flag que indica que no hay nada en el estado de descarga
                inDownloadFlag = 0;

        }

}

// Esta es una funcion normal en C++ para borrar las etiquetas HTML del strng.
// No comentare esto. Esto no es Enigma. Esto es programacion normal en C++.
eString removeTags(eString in)
{        eString out;
        int startpos = 0; int length = 0;
        for(unsigned int i = 0; i < in.length(); i++)
        {        length++;
                if(in.mid(i, 1) == "<")
                {        out = out + in.mid(startpos, length - 1);
                        for(unsigned int j = i; j < in.length(); j++)
                        {        if(in.mid(j, 1) == ">")
                                {        i = j;
                                        startpos = i + 1;
                                        length = 0;
                                        break;
                                }
                        }
                }
        }
        if(out == "")
        {        out = in;
        }
        return out;
}



eBibleMainWindow::~eBibleMainWindow()
{
        // No tenemos que hacer nada mas aqui. todos los objetos seran borrados automaticamente
        // Hasta un niño lo podria hacer. El eWidget-destructor lo hara por nosotros.
}
--------------------------------------------------------------------------------
 
Ya puedes practicar la compilacion de codigo fuente que podras encontrar en el paquete adjunto y modificarlo.

Ejercicios:
- Cambiar el codigo para que funcione con otra web.

Esto es todo, y esta es la captura de la aplicacion y el paquete completo.
Este tutorial acaba aquí.

Espero haberte ayudado.

Pasadlo bien.
Recuerdo de Meo aka bacicciosat.


No tienes permiso para ver los enlaces. Regístrate o Autentícate



Muchas Gracias Nesi-tor
« Última modificación: 10/06/2008, 23:36 por elgeneral »
 

GoogleTagged



Related Topics

  Asunto / Iniciado por Respuestas Último mensaje
normal_post * 0 Respuestas
6045 Vistas
Último mensaje 14/06/2008, 19:15
por elgeneral
normal_post * 1 Respuestas
1731 Vistas
Último mensaje 19/06/2008, 21:05
por koala
normal_post * 0 Respuestas
1025 Vistas
Último mensaje 24/06/2008, 19:30
por elgeneral
normal_post * 0 Respuestas
1018 Vistas
Último mensaje 13/06/2008, 04:28
por elgeneral
normal_post * 0 Respuestas
1806 Vistas
Último mensaje 12/05/2008, 08:01
por elgeneral
normal_post * 4 Respuestas
2702 Vistas
Último mensaje 29/04/2018, 08:57
por josagi
normal_post_sticky * 3 Respuestas
3520 Vistas
Último mensaje 14/09/2008, 12:42
por elgeneral
normal_post_locked * 0 Respuestas
1680 Vistas
Último mensaje 26/11/2008, 18:49
por josagi
normal_post * 0 Respuestas
2174 Vistas
Último mensaje 05/04/2009, 17:06
por chris...62
normal_post * 0 Respuestas
2938 Vistas
Último mensaje 20/07/2011, 23:42
por ligmer



PadreDeFamilia
!! ADVERTENCIAS !!: Las informaciones aquí publicadas NO CONTIENEN KEYS para la decodificación de ningún sistema: NO SON OPERATIVOS en sistemas SAT que precisen de su correspondiente suscripción. ESTA TOTALMENTE PROHIBIDO EL USO DE ESTAS INFORMACIONES PARA LA MODIFICACIÓN O DEFRAUDACIÓN DE SISTEMAS DE ACCESO CONDICIONAL. ESTOS FOROS SON MODERADOS Y NO SE PERMITE LA PUBLICACIÓN DE INFORMACIONES ILEGALES POR PARTE DE LOS USUARIOS. EN CASO DE DETECTARSE ESTE TIPO DE INFORMACIONES, LOS USUARIOS SERÁN EXCLUIDOS DE ESTAS PÁGINAS.
PROHIBIDA LA PUBLICACIÓN DE ENLACES A FIRMWARES ILEGALES