Receptores LINUX - ANDROID > DreamBox
Enigma 1, la biblia en español
elgeneral:
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.
elgeneral:
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 ... )
[archivo adjunto borrado por el administrador]
elgeneral:
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 ... )
[archivo adjunto borrado por el administrador]
elgeneral:
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 ... )
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
gonzc5:
Una maravilla amigo.
Navegación
[#] Página Siguiente
Ir a la versión completa