Libro AMS 8_0 creado por Douglas A_ Rivera Castillo Edición Web

LIBRO PROGRAMACION LUA

LIBRO DE SCRIPTING EN AMS 8 Tomo 1, Año 2011 1

http://i50.tinypic.com/2gvv3w8.png



LIBRO PROGRAMACION EN AMS 8

Manejo del motor de script LUA en AMS

Escrito por: Douglas A. Rivera Castillo

Año 2011




INDICE

1. Ventajas de la Programación orientada a objetos…………………..….Pág.

2. Conociendo el área de trabajo ……………………………………….….……..Pág.

3. El área de trabajo …………………………………………………………….…….…Pág.

4. Barra de menús …………………………………………………………………….….Pág.

5. Barra de botones Standar …………………..…………………………………....Pág.

6. Teoría del script…………………………….……………………………….............Pág.

7. Palabras clave reservadas por LUA…………………………………............Pág.

8. Explicación de las palabras clave……………………………………………….Pág.

9. Los signos matemáticos…………………………………………………………….Pág.

10. Como hacer y dejar comentarios………………………………………………Pág.

11. Que son las variables…………………………………………………….………….Pág.

12. Teoría del script 2 que son las variables……………………………………Pág.

13. Teoría del script 3 estructuras de control……………….………………..Pág.

14. Probar valores numéricos…………………………………………………..……Pág.

15. Teoría del script 4 estructuras de control uso del ciclo for………..Pág.

16. Teoría del script 5 estructuras de control uso de for y do…………Pág.

17. Manejo de tablas……………………………………………………………………..Pág.

18. Global y Event Variables…………………………………..………………………Pág.

19. Variables globales (Global variables)………………………………………..Pág.

20. Variables Globales si usas GlobalPaths Action Plugin……………….Pág.

21. Event variables………………………………………………………………………..Pág.

22. Creación de Funciones…………………………………………………………….Pág.

23. Uso y creación de las máscaras……………………………………………….Pág.

24. Uso de menús……………………….………………………………………………..Pág.

25. Bases de datos en SQLite…………………………………………………………Pág.

26. Ejercicios…………………………………………………………………………………Pág.




Ventajas de la Programación orientada a objetos

Reduciendo el tiempo de desarrollo

Usando la Orientación a Objetos para Reducir el Tiempo de Desarrollo

Introducción

Autoplay Media Studio es Orientado a Objetos. ¿Qué es lo que hace eso por

mí? ¿Cómo la orientación de objetos puede hacer mi vida más fácil? Todos

sabemos que hay una curva de aprendizaje a subir para entender qué nos han

dicho sobre objetos y que hay una recompensa al subir esa curva. En este

artículo mostrare una de las recompensas, una reducción para nuestro tiempo

de desarrollo.

Tiempo de Desarrollo

El tiempo de desarrollo es siempre muy importante y los pasos que tomamos

para reducir este tiempo son muy valiosos. La orientación a objetos nos

promete que nuestro trabajo será reusable y que cada proyecto que nosotros

desarrollamos tomará menos tiempo que el anterior. ¿Cómo nos cobramos esa

promesa?

Como es el caso en todas las situaciones, la solución a un problema nunca se

encuentra hasta que el problema sea entendido y definido claramente. El

tiempo de desarrollo puesto bajo un microscopio nos muestra que está

dividido en varias tareas diferentes. Las mayores son el análisis, diseño,

implementación, prueba, y entrenamiento del usuario. ¿Cuáles son estas tareas

y cómo influyen éstas en el tiempo global de desarrollo?




Análisis

Todo el desarrollo de la aplicación empieza con el análisis del problema

comercial a ser resuelto. Un análisis completo es crítico para una solución

exitosa. Nos dicen que en el desarrollo orientado a objetos, la fase de análisis

ocupará un porcentaje más grande del tiempo de desarrollo total que en las

prácticas de programación estructuradas del pasado. ¿Qué podemos hacer para

reducir el tiempo requerido para esta fase de un proyecto?

Buscando patrones en problemas comerciales reduciremos bastante el tiempo

destinado al análisis. Catalogando estos patrones cuando los identifiquemos

nos permitirán descubrirlos más fácilmente en el futuro. Con un catálogo de

patrones en nuestras manos podremos reconocer rápidamente similitudes a los

problemas comerciales anteriores y rápidamente podremos registrar los

requerimientos.

Hay un peligro en cualquier esfuerzo para reducir el tiempo de análisis es el de

producir un análisis incompleto. Cuando cortamos esquinas sobre el análisis

de un problema de negocio nosotros potencialmente abrimos el proyecto a una

cantidad de problemas que van a consumir tiempo. Es posible que no se

descubran requisitos perdidos hasta que el proyecto esté bien encaminado para

su finalización y que esos requisitos no descubiertos nos obliguen a abandonar

un grupo grande de trabajo debido a los cambios en el diseño.

Si el problema de negocio no es entendido claramente por los diseñadores y

programadores de una aplicación, es probable que la aplicación no satisfaga

las necesidades del usuario. Las aplicaciones que no reúnan los requisitos de

los usuarios son abandonadas o escritas de vuelta. Es asustadiza cómo

verdadera la vieja frase: "Nunca hay bastante tiempo para hacerlo

correctamente, pero siempre hay bastante tiempo para hacerlo encima."

Aparte de reconocer, usar, y catalogar los patrones vistos durante el análisis,

ésta es una de las dos áreas del proceso de desarrollo que no debe abreviarse.




Diseño

El diseño es la abstracción de una solución, en otras palabras es la descripción

general de la solución a un problema sin los detalles. Así como pueden

categorizarse problemas de negocio en patrones que se repiten, los diseños

también exhiben patrones. Patrones vistos en la fase del análisis pueden ser

trazados en el diseño. Catalogando y reusando patrones de diseño podemos

reducir el tiempo requerido para crear el diseño de la solución.

La fase de diseño es el segundo paso de desarrollo que no debe abreviarse. Es

sorprendente qué fácil y rápida pueden lograrse las metas cuando esta fase se

define claramente. La fase de diseño es la planificación de la solución, sin un

buen diseño podemos seguir un gran número de puntos muertos. Estos puntos

muertos consumirán mucho más tiempo que el desarrollo del propio diseño en

sí.

Comparando la construcción de una aplicación con una vacaciones en familia.

¿Si, en el momento de las vacaciones, usted metió a su familia dentro del

automóvil y empezó a manejar para cruzar el país y usted no tenía ningún

mapa y ninguna ruta planeada, piensa usted que en esas condiciones alcanzará

su destino? ¿Cuántos malos giros podría tomar usted en el viaje? ¿Cuánto

tiempo le tomaría estar al otro lado del país? Construir una aplicación sin un

buen diseño es algo muy parecido.

Implementación

La implementación es la ejecución del plan de diseño. Esta parte es donde

nosotros escribimos el código que hace realmente el trabajo. Este artículo se

enfoca en técnicas para reducir el tiempo de la fase de implementación del

desarrollo de una aplicación.

Empezando con un legítimo framework pueden reducir el codificado de la

aplicación quitando la necesidad de tratar con las actividades rutinarias de las

interacciones del componente.

Reusar código previamente exitoso ha sido una meta para programadores

desde hace mucho tiempo. La orientación a objetos promete, de nuevo,

permitir la reusabilidad de nuestro código, a pesar de que la orientación a




objetos nos permite reusar no más que código. Nosotros podemos reusar cosas

reales, widgets. Estos widgets pueden ser tan simples como un cuadro de texto

que maneja entradas de fecha, o tan complejo como un formulario que maneja

la administración de los datos. Un framework es un widget reusable muy

complejo comprendido por muchos objetos que proporcionan un servicio a la

aplicación.

Usted puede reconocer widgets útiles durante el desarrollo de un proyecto.

Una vez que usted se encuentra haciendo la misma cosa por segunda vez,

deténgase y pregúntese si esto podría ser manejado por un widget reusable.

Prueba

Las pruebas pueden extenderse a lo largo de un proyecto y también después de

su finalización. Probamos cosas cuando las construimos y entonces de nuevo

las probamos cuando el proyecto está completo para cerciorarnos que ellas

trabajan bien juntas. Cuando estamos reusando widgets previamente probados,

ahorramos un poco de tiempo porque estos elementos reusables ya se han

probado individualmente, quedándonos solamente por probarlos en unión con

los demás elementos.

Formación

La formación del usuario es uno de los aspectos pasados por alto a menudo, y

centro del costo, del desarrollo de la aplicación. Una nueva aplicación no hace

nada bueno para el negocio hasta que los usuarios puedan hacerla trabajar.

Mediante la capitalización sobre componentes reusables promovemos una

interface consistente para nuestras aplicaciones. Esto, a su vez, reduce el

tiempo de formación requerido para que los usuarios se sientan cómodos con

el nuevo sistema porque ellos ya están familiarizados con la interface del

usuario.




Los Principios de la Reusabilidad Promovida en la POO

El desarrollo de sistemas orientados a objetos tiene un conjunto de principios

y reglas que prescriben la manera en que deben hacerse las cosas. Se oye de

todos a menudo que la teoría es buena pero el pragmatismo se apodera del

trabajo hecho. Esta es una actitud infortunada para los desarrolladores de

software que usan herramientas orientadas a objetos. No se fundaron los

principios de orientación a objetos en algún cuarto de la parte trasera de una

universidad, ellos se descubrieron durante el desarrollo de un proyecto real a

través del análisis de cosas que no funcionaban.

Estos principios y reglas son pautas hacia el éxito y ellos necesitan ser

respetados y entendidos. Siguiendo las reglas, éstas nos protegen de cometer

errores que otros ya han cometido antes. Es verdad que cualquier regla puede

romperse, sin embargo también es verdad que antes de romper una regla uno

debe:

1. Saber que la regla existe.

2. Saber lo que es la regla.

3. Saber por qué las reglas existen

4. Saber los problemas potenciales relacionados con el rompimiento de la

regla.

Si usted sabe todas estas cosas y todavía escoge romper la regla, prosiga y

rómpala. ¿Qué tiene de malo todo esto? Significa que es necesario saber lo

que son las reglas y principios del desarrollo orientado a objetos. Significa que

la "teoría" no es dispensable.

Las siguientes secciones discuten algunos de estos principios y examinan, a

través de los ejemplos, cómo estos promueven la reusabilidad y reducen el

tiempo de desarrollo.




Delegación

La delegación es el proceso donde un objeto pasa la responsabilidad de una

acción a otro objeto diferente. Esto normalmente se hace debido a las

responsabilidades naturales de los dos objetos en cuestión. Por ejemplo,

considere que un botón de comando es responsable de cerrar un formulario.

¿La responsabilidad del botón es reaccionar al usuario cuando este pulse el

botón, pero es el botón el que tiene la responsabilidad de cerrar el formulario?

Quizás el propio formulario está mejor preparado para realizar su propia

acción de cierre. A través de la delegación podemos llevar el paso de la

responsabilidad del botón, que es de cerrar el formulario, al propio formulario.

Ejemplo del botón btnSalir

El código del evento On click del botón delega la responsabilidad al

formulario mediante una llamada al Application.Exit() quitando así la

responsabilidad del botón para manejar los detalles de cerrar el formulario.

Con el uso apropiado de la delegación separaremos la funcionalidad de una

operación en particular y asignaremos la responsabilidad al objeto más

apropiado. Esto proporciona la habilidad de ejecutar independientemente

pedazos de esa funcionalidad, que a su vez reduce los requerimientos para los

procedimientos monolíticos (métodos) que son esencialmente grandes

estructuras DO CASE. Estos procedimientos monolíticos son una molestia

mayor durante la fase de mantenimiento de un proyecto.

Herencia

Definido como la posibilidad que tiene una clase de incorporar toda o una

parte de otra clase en su propia definición, la herencia probablemente es la

mayor propiedad del desarrollo orientado a objetos y, al mismo tiempo, el más

usada. La herencia es el proceso por el que una subclase recibe conductas y

datos de su clase antecesora. La idea es que mientras más extenso es el árbol

de herencia la definición de las clases se vuelven más especializadas.




Mientras que la herencia un rasgo poderoso de los lenguajes orientados a

objetos, también es limitando. Siempre que intentemos modificar una clase en

la jerarquía también necesitaremos determinar lo que este cambio afectará a

todas las clases descendientes. Cuando un árbol de herencia crece hasta llegar

a ser muy grande la habilidad de reusar cualquiera de las clases individuales

dentro de ese árbol será más difícil.

Sin embargo puede usarse la herencia para mantener el polimorfismo.

Definiendo propiedades y métodos públicos de una clase entera de objetos en

la cima del árbol de herencia podemos estandarizar la interface de

programación y asegurarnos que las clases sean intercambiables.

Polimorfismo

Polimorfismo: La capacidad que tiene una funcionalidad de aplicarse en

distintas formas. Hay dos tipos de polimorfismo:

Inherente: La funcionalidad es heredada por cada subclase.

Ad hoc: Las distintas funcionalidades de tipos diferentes tienen el mismo

nombre.

Definiendo una clase abstracta que introduzca todos los métodos y

propiedades públicas de un árbol de la clase entera nosotros podemos

mantener consistente la interface de un programador y asegurarnos que todas

las subclases sean intercambiables. En otras palabras, si todas las clases de

cuadros de texto tienen el mismo conjunto de propiedades y métodos públicos

serán intercambiables. Nosotros podemos reemplazar fácilmente un tipo de

cuadro de texto por otro sin preocuparnos por algún otro objeto que se refiera

a una propiedad o método que el nuevo cuadro de texto no tenga. Éste es el

polimorfismo inherente.

Ejemplos del inpBase, inpCalculator, y inpDate

El inpBase define la interface pública para todos los cuadros de texto. El

inpCalculator y inpDate heredan de la clase inpBase manteniendo así estándar

la interface de programación para esos cuadros de texto y permitiéndoles ser




intercambiados sin la necesidad de alterar cualquier código fuera de los

cuadros de texto.

El polimorfismo ad hoc puede verse en la clase botón de btnSalir. Sobre

Delegación, nosotros mencionamos que el botón pasa la responsabilidad al

formulario para la acción de cierre. Esto es cumplido por el código del evento

On click del botón que llama al método Salir del formulario. Los diferentes

formularios pueden tomar acciones diferentes en sus métodos Salir respectivos

y pueden significar que el código en el evento On click del botón de salida

está aprovechándose del polimorfismo ad hoc para proporcionar reusabilidad.

El botón btnSalir puede ser arrojado en cualquier formulario y funcionará

eficazmente.

Encapsulación

La encapsulación puede definirse como esconder la aplicación de un objeto.

Cuando una clase contiene todos los datos y código requeridos para que pueda

funcionar sin la necesidad de depender de cualquier objeto externo al runtime,

decimos que está encapsulada. Esta encapsulación permite usar la clase sin

tener en cuenta el entorno en donde se la coloca. La clase no requiere nada

específico de su entorno y no crea ningún efecto en el lado del entorno. La

encapsulación es muy eficaz haciendo clases reusables.

Ejemplo del cntProgress

Se definen todas las propiedades y métodos necesarios como parte de la clase

haciendo la clase independiente de cualquier objeto externo al runtime. Esto

permite que la clase cntProgress sea virtualmente puesta en cualquier

formulario sin tener en cuenta que pueda o no haber en ese formulario.

Independencia

La independencia es un paso para lograr encapsulación. Haciendo una clase

independiente requiere que cualquier referencia a las propiedades o métodos

de otro objeto sea verificada antes de hacer dicha referencia. Esto es llamado a

veces "programación defensiva". Nosotros podemos hacer una clase




independiente no asumiendo nada sobre el entorno en el que esa clase puede

encontrarse. No asumiendo el significado de verificar que para la existencia de

cualquier cosa nosotros necesitamos antes tratar de usarla.

Ejemplo del tmrTimeOut

El evento timer verifica la existencia de una propiedad llamada On Timer en

el formulario contenedor antes de intentar hacer una referencia a ella. Esto

permite poner el cronómetro en un formulario sin tener en cuenta si ese

formulario tiene o no una propiedad llamada On Timer.

Usando Colecciones

Las distintas clases de base de Autoplay Media Studio tienen colecciones de

sus objetos miembros, entre éstos el Formulario, Container, Grid, PageFrame,

Page, etc. Esta colección de propiedades hacen posible referirse al objeto

miembro contenido sin saber algo de ellos, como sus nombres o el número de

ellos que existen en el objeto. Usar estas colecciones nos hacen posible

escribir código que trabajará con una variedad de configuraciones del objeto

contenedor.

Resumen

Los principios del desarrollo orientado a objetos, como Herencia,

Polimorfismo, Encapsulación, Mediación, y Composición, sostienen la

creación de clases reusables. Aplicando estos principios eficazmente las clases

que vamos a crear pueden ser usadas muchas veces sobre una variedad de

configuración diferente. Sin embargo, este reusabilidad no viene gratis,

nosotros debemos crear activamente nuestras clases para que sean reusables

prestando mucha atención a nuestro diseño y codificado.

Hay grados de reusabilidad, como reusable dentro de los límites de un área de

trabajo particular contra reusable sobre las áreas de trabajo múltiples. El grado

más alto de reusabilidad, es el que nosotros debemos planear para la clase que

vamos a crear.




Conociendo el área de trabajo

En esta clase veremos y conoceremos toda el área de trabajo de AMS,

partiremos desde como abrir AMS.

Como abrir AMS: Damos doble click en este icono cuando lo

hayamos dado nos cargara el programa una vez cargado el programa veremos

la siguiente venta:

en esta venta nos aparece Tres (3) Botones los cuales procedo a explicar cada

uno de ellos.


http://i47.tinypic.com/a496jr.png

http://i48.tinypic.com/wat6hz.png

http://www.alucardwarez.net/pic/pictures/9cc4a6ddce7b2e191e0e51c55d892f68.png



















: Este Botón en español significa Crear un Nuevo Proyecto. El cual nos

desplegara una nueva ventana en la cual nos mostrara una serie de plantillas

predeterminadas de AMS que se ve de la siguiente manera:

en ella seleccionamos la plantilla que más nos guste luego en la parte inferior:

y una vez colocado el nombre del proyecto damos un click en el siguiente

botón:

si al final decidimos no hacer nada le damos al botón


http://www.alucardwarez.net/pic/pictures/a82c5839b342aec2aa8c522acc5a2443.jpg

http://www.alucardwarez.net/pic/pictures/31d8af9447249d7accffa7b5e0e2bcd4.jpg

http://www.alucardwarez.net/pic/pictures/c05ba01bd29d4e4f946134fa91c10b22.jpg

http://i50.tinypic.com/34t8qxl.jpg

http://i46.tinypic.com/2u4rd02.jpg

































: Este botón en español significa Abrir un Proyecto Existente.

Por lo cual con este botón podemos abrir nuestros proyectos cuando queramos

de una manera rápida aparte de ello cuenta con un sub menú en la parte

derecha es la flecha de color negro que miran y cuando damos click sobre ella

nos muestra un menú así como este: ahí nosotros seleccionamos alguno de los

últimos proyectos abiertos.

:Este botón en español significa Restaurar el último proyecto abierto.

y pues como su propio nombre lo dice restaurar nuestro último proyecto

abierto en AMS dando un Click sobre el botón.



http://www.alucardwarez.net/pic/pictures/5ba6003f0e7155efd90cf28d90560275.jpg

http://www.alucardwarez.net/pic/pictures/0623dee99685cc002caf980dfead9582.jpg

http://www.alucardwarez.net/pic/pictures/0048a0ea4607c2fe3b735a31bcf19739.jpg


















EL ÁREA DE TRABAJO

Continuando con esta etapa de AMS tenemos la captura del área de trabajo de

AMS en la parte superior y a continuación les desglosare cada una de las

partes tratando de explicarlas lo más claras posibles.

Barra de Menús


http://www.alucardwarez.net/pic/pictures/d3261e4d6a7683a4f38242112ce93ce5.jpg

http://www.alucardwarez.net/pic/pictures/e30cba72285a3d85568463db54f17789.jpg









En esta barra encontraras todos los menús de AMS de una manera muy

ordenada cuando presionamos con el ratón nos en alguna de sus opciones nos

despliega un menú así como este:

De esa manera se mostrara cada uno de ellos con forme vallamos pasando el

puntero del ratón sobre ellos.

Barra de Botones Standar


http://www.alucardwarez.net/pic/pictures/ceae4487c853a62008389d312b5e0ce6.jpg

http://www.alucardwarez.net/pic/pictures/afaa7609ad27bad7130c3c0fe8211b65.jpg









En esta barra encontraras una serie de botones con las acciones más comunes

para trabajar, en ella tenemos los botones ordenados de una manera muy clara

y entendible.

A continuación desglosare cada uno de los botones explicándoles cual es la

función de ellos.

Crea un proyecto nuevo.

Abre un proyecto ya existente.

Guarda un proyecto, o guarda los cambios realizados a un proyecto.

Corta un objeto seleccionado.

Copia un objeto seleccionado.

Pega algún objeto previamente cortado o copiado.

Retroceder o Avanzar.

Vista previa del proyecto.

Empaquetar el proyecto.

Agregar objeto de botón.

Agrega objeto de imagen.

Agrega objeto de etiqueta.


http://i47.tinypic.com/t6bbed.png

http://i48.tinypic.com/vcz62e.png

http://i45.tinypic.com/2uji8if.png

http://i47.tinypic.com/xghd7m.png

http://i47.tinypic.com/1o118j.png

http://i46.tinypic.com/2z8an0w.png

http://i49.tinypic.com/10608jb.png

http://i49.tinypic.com/1608wvq.png

http://i48.tinypic.com/v6qexg.png

http://i47.tinypic.com/insuhl.png

http://i49.tinypic.com/jq1bu1.png

http://i50.tinypic.com/35am9vp.png































































































































































Agrega objeto de Párrafo.

Agrega objeto de video.

Agrega objeto de video QuickTime.

Agrega objeto Flash.

Agrega un objeto de SlideShow.

Agrega un objeto PDF.

Agrega un objeto web.

Agrega un objeto de XButton.

Agrega un objeto CheckBox.

Agrega un objeto RadioButton.

Agrega un objeto Input.

Agrega un objeto ComboBox.

Agrega un objeto ListBox.

Agrega un objeto Tree.

Agrega un objeto Grid.


http://i49.tinypic.com/2v2e64n.png

http://i48.tinypic.com/199j53.png

http://i49.tinypic.com/244dy5l.png

http://i46.tinypic.com/2m7dttx.png

http://i48.tinypic.com/xlw1kw.png

http://i48.tinypic.com/5chxg3.png

http://i49.tinypic.com/rw14jo.png

http://i48.tinypic.com/depu2b.png

http://i49.tinypic.com/1zldh8k.png

http://i49.tinypic.com/2m6uyol.png

http://i46.tinypic.com/j0f89f.png

http://i46.tinypic.com/2ib21sh.png

http://i46.tinypic.com/mrschk.png

http://i48.tinypic.com/2s0lnbm.png

http://i45.tinypic.com/mllgg5.png



















































































































































































































































Agrega un objeto Pregress.

Agrega un objeto RichText.

Agregar un objeto Hotspot.

OTROS CONTROLES

Shape: Es un control gráfico que se muestra como un rectángulo, un

cuadrado, una elipse, un círculo, un rectángulo redondeado o un cuadrado

redondeado.

RichTextBox: Es un control que permite al usuario escribir y modificar texto

al tiempo que proporciona características de formato más avanzadas que el

control TextBox convencional.

DataGrid (Control): Muestra y permite la manipulación de datos de una serie

de filas y columnas que corresponden a registros y campos de un objeto de

base de datos u otro tipo de datos.

Control Calendar: Es una control que permite introducir en una aplicación

uncalendario personalizado.

Estas opciones son de

lineamiento de los objetos en nuestro proyecto.


http://i49.tinypic.com/6783mq.png

http://i47.tinypic.com/2po48rq.png

http://i49.tinypic.com/j5ggo2.png

http://www.alucardwarez.net/pic/pictures/b87661adb18466c51b8ff6dec908ebf7.png























Este es el panel de Exploración de todo nuestro

proyecto aquí podrán ver todos las hojas o formularios y sus objetos de una

manera de árbol.

Este es el panel de propiedades para todos los

objetos de nuestro proyecto, solo debes de seleccionar el objeto y te mostrara

todas las propiedades de dicho objeto en caso de que no tengas seleccionado

nada solo te mostrara las propiedades de la hoja.


http://www.alucardwarez.net/pic/pictures/99735a7741a531d621883c59377c2320.png

http://www.alucardwarez.net/pic/pictures/fa764340d946d1815230ae8c30418388.png









Esta es el área de trabajo en la cual desarrollamos nuestros trabajos estas son

llamadas hojas, también contamos con otras formas de hojas llamadas

DialogEx son una gran herramienta a la hora de desarrollar software con multi

formularios tienen una flexibilidad muy completa.

Bueno una vez explicado el funcionamiento de cada una de las herramientas

básicas de AMS procedemos a la clase, primero que nada les recomiendo lean

completo todo una o dos veces para que se aprendan bien que es lo que hace

cada herramienta y no tengan que estar viendo cada vez que ocupen hacer algo

este tema, la intención de todo esto es hacerte un experto que no ocupes ver

algo para poder hacer tus programas.

Lo que aremos a continuación será muy sencillo abriremos AMS y crearemos

un proyecto nuevo le pondrán por nombre MI PRIMER EJERCICIO y le

colocaran una Etiqueta con el nombre de ustedes y una foto de cualquier cosa,

luego le colocaran un color de fondo o un degradado una vez terminado lo

guardaran y lo ejecutan.


http://www.alucardwarez.net/pic/pictures/70ebffc5db4ea685d67eab775f4ebfca.png


http://www.alucardwarez.net/pic/pictures/70ebffc5db4ea685d67eab775f4ebfca.png



A continuación les explicare como desarrollar este ejercicio.

Pasos para desarrollo de la Tarea 1:

1- Abrimos AMS

2- Creamos un proyecto en blanco y le ponemos por nombre MI PRIMER

EJERCICIO 3- Les cargara el área de trabajo y ahí agregaren los dos objetos que se le

piden.

4- Colocaran un color de fondo o degradado.

Como hacer el paso 4:primero debemos de acceder a las propiedades

de la hoja lo pueden hacer dando Click derecho en la pestaña que tiene

el nombre de la hoja así como se muestra en la imagen luego de ello se

abrirá una nueva ventana y nos dirigimos a esta opción ahí activamos la

caja de selección y nos activara todas esas opciones las cuales son para

personalizar tu hoja de trabajo nosotros nos dirigimos a la que dice

Soild color o gradient y les activara una paleta de colores y ahí

seleccionan el o los colores que quieran que tenga y listo ya una vez

hecho eso le dan un Click al botón aceptar y ya estarán aplicados los

cambios.


http://www.alucardwarez.net/pic/pictures/3e11ef4834a0d980150bd6839ef51e06.png




5- Guardar el proyecto en formato APZ

Como hacer el paso 5:

se dirigen a la barra de menús y dan Click en la opción FILE les desplegara el

menú y darán Click en la opción EXPORTER, antes de ello ya deben de haber

guardado su proyecto normal mente con el botón de guardar para que los deje

Exportar, la opción EXPORTER se verá a si

en la imagen sale marcada SAVE AS

pero no es la inferior la que usaran, una vez seleccionada esa opción les abrirá

una nueva ventana que se vera de la siguiente manera colocaran un nombre a

su proyecto y le dan al botón guardar antes de guardar elijan donde lo quieren

guardar y listo.


http://www.alucardwarez.net/pic/pictures/020c8403fba24a7c3744752cafe9cbe9.png

http://www.alucardwarez.net/pic/pictures/3afaf383b7b1f68c0650294b70b188aa.png













http://www.alucardwarez.net/pic/pictures/c568c387947bbd035c352c4ce4fde167.png


http://www.alucardwarez.net/pic/pictures/c568c387947bbd035c352c4ce4fde167.png



Teoría del Script

Empezaremos enseñando la sintaxis de LUA, como cualquier lenguaje de

programación, consta de una sintaxis y de una manera de escribir,

afortunadamente, la de LUA es de las más sencillas que hay.

Así que empecemos.

nombre = Input.GetText("nombre")

if nombre == "douglas" then

Dialog.Message("hola", "Douglas")

end

Ahora parte por parte.

nombre = Input.GetText("nombre") : Esta parte da una variable la cual

almacena una cadena, el valor almacenado en la variable es una lectura de una

Input llamada "nombre".

if nombre == "douglas" then : es la condición de que si nombre "la Input"

contienen dentro de ella el valor "douglas" realizara una acción, que se le dará

posterior mente.





Dialog.Message("hola", "Douglas") : esta es la condición a realizar si el

valor es el correcto en este caso la lectura del nombre douglas en la input

llamada nombre.

end : pues esta parte es el cierre de la condición si abrimos un if cerramos con

un end

espero me haya explicado bien si tienen dudas las dejan en el foro de

discusiones.

Palabras claves Reservadas por LUA

and

break

do

else

elseif

end

false

for

function

if

in

local

nil

not

or

repeat

return

table

then

true

until

while

Esas son las palabras que no podemos usar como variables ni como nombres

de objetos ya que son palabras reservadas por AMS, pero recordemos de que

AMS es sensible a las MAYÚSCULAS y MINÚSCULAS y por lo tanto

podemos usar estas palabras si las colocamos en Mayúsculas, pero eso sería

un problema a la hora de trabajar ya que se confundirían muy fácil mente, por

ello no les recomiendo hacer eso.





Explicando que significa cada palabra clave

if nos da la condicional de si ocurre algo.

elseif nos sigue dando también una condicional, pero si no ocurre el if

anterior.

else se usa para dar una acción de que si ocurre lo contrario del if

and nos sirve para añadir otra condicional al if, por ejemplo, "if douglas and

agotaras".

or es un O en castellano vamos, suele complementar al if, if douglas or

Douglas.

then es un entonces, cuando acabamos el if ponemos un then para empezar

a poner la función del script. Por ejemplo, if douglas == “Douglas” then

Dialog.Message("hola", "Douglas")

end nos permite cerrar una función, se ponen los end al final casi siempre, y

se pone un end en cada función if para cerrar la operación.

return nos permite volver a hacer una acción, por ejemplo return onUse,

será para volver a la función onUse

true/false nos permite decir que si un valor es cierto o falso, siempre van en

MINUSCULA.























Los Signos matemáticos

Los signos matemáticos de LUA, son como todos, pero los explicaré.

+ Sirve para sumar cantidades.

- Sirve para restar cantidades.

* Sirve para multiplicar cantidades.

/ Sirve para dividir cantidades.

= Para dar igualdades.

> Mayor que.

< Menor que.

== Es igual a.

>= Mayor e igual que.

<= Menor e igual que.

Ejemplo de uso de los operadores matemáticos

cantidad_1 = Input.GetText("Input1")

cantidad_2 = Input.GetText("Input2")

operacion = cantidad_1 + cantidad_2

Resultado = Dialog.Message("Respuesta" ,

operacion)





Explico paso a paso:

cantidad_1 = Input.GetText("Input1") : la primera parte es una variable

que almacena la lectura de una input en esta caso la Input1.

cantidad_2 = Input.GetText("Input2") : la primera parte es una variable

que almacena la lectura de una input en esta caso la Input2.

operacion = cantidad_1 + cantidad_2 : en esta parte operación es la variable

la cual almacena la operación matemática que en este caso es una suma de los

valores escritos en la Input1 y la Input2.

Resultado = Dialog.Message("Respuesta" , operacion): esta pues es una

variable la variable es Resultado y ella almacena un Mensaje de Dialogo el

cual nos dará el resultado dado de la sumatoria de las dos input pero la lectura

la hace por medio de la variable operacion

Nota: este método de uso de variables y combinación con cadenas es muy

fácil de entender y nos ahorra mucho trabajo de escritura.

La misma script se aria para cualquier otra operación matemática suma, resta,

multiplicación, división, etc.

Una de las cosas muy importantes a la hora de estar programando es el dejar

comentarios en cada parte importante de nuestros script eso no es para que se

mire bonito no que seas extremadamente ordenado no, eso se hace para tener

el script bien legible para nosotros mismo así como para otros que lo lean

después, para que su comprensión sea más rápida y no compliques mucho a la

hora de buscar algo en específico.




Yo en lo personal uso mucho los comentarios en casi todo el desarrollo de los

script y lo hago para ayudarme a mí cuando tengo un error lo encuentro rápido

y si busco alguna parte de un script viejo para usarlo en un programa nuevo

solo canibalizo la parte que ocupo y como le tengo un comentario ya sé dónde

inicio y donde termina y me ahorro mucho tiempo de comprobar si está bien el

script.

Como hacer y dejar Comentarios

Se pueden insertar comentarios no ejecutables dentro de tus scripts para

explicar y documentar tu código. En un script, cualquier texto después de dos

guiones (--) en una línea será ignorado.

Por ejemplo:

-- hola es almacena un nombre

hola = Douglas

o lo podemos dejar después del script.

Ejemplo:

hola = Douglas -- hola es almacena un nombre

Los dos ejemplos hacen lo mismo, los comentario de las dos maneras que se

agregaron no afectan en nada al desarrollo del script por lo tanto lo pueden

usar de esas maneras.

Aunque también podemos hacer comentarios multi lineales, a que me refiero





con lo de multi lineales, pues es sencillo crear un comentario grande pero no

usar en la línea los guiones pues la solución es muy fácil, los creamos usando

los corchetes [ ] pero debemos de colocar al inicio siempre los dos guiones.

Ejemplo de uso:

--[[ Hola Alumno

Te saluda tu Profesor:

Douglas A. Castillo]]—

¿Qué son las Variables?

Las variables son muy importantes en el Script de Autoplay. Las variables son

simplemente “apodos” o “contenedores” para valores que podrían necesitar

modificarse o reutilizarse después.

Ejemplo: el siguiente script asigna un valor de caracteres a una variable en

este caso el valor asignado es "Douglas"

Hola = Douglas

Nota: Decimos que los valores son “asignados a” o “almacenados en”

variables. Si describes una variable como un contenedor que contiene un

valor, asignar un valor a una variable es como “colocar” ese valor dentro del

contenedor. Puedes cambiar este valor en cualquier momento asignándole un

valor diferente a la variable; el nuevo valor simplemente reemplazará al

anterior. Esta habilidad para contener información cambiable es lo que hace a

las variables tan útiles.





Ejemplo de uso de variables:

numero = 100;

numero = numero + 20;

Dialog.Message("Valor", numero);

Esto almacena 100 en la variable llamada “numero”, luego añade 20 a ese

valor, y finalmente hace que un cuadro de diálogo aparezca con el valor actual

(el cual es ahora el número 120) en él.

TAREA 1

1- Cree un proyecto en blanco

2- Agregue Dos Input

3- Agregue un Botón

4- en el Botón en la pestaña Script en el procedimiento On Click, cree un

script que me haga una División de las Input.

5- Guardar la tarea en formato APZ.

6- Desarrolle el script correspondiente en su libro de trabajo.

SCRIPT





TAREA 2

1- Cree un proyecto en blanco

2- Agregue Dos Input

3- Agregue un Botón

4- en el Botón en la pestaña Script en el procedimiento On Click, cree un

script que me haga una Resta y Multiplicación de las Input.

5- Guardar la tarea en formato APZ.

6- Desarrolle el script correspondiente en su libro de trabajo.

Script




Teoría del Script 2 Las Variables

AMS como todo software de desarrollo usa variables y strings.

Las strings no son más que texto respondiendo a acciones determinadas.

Las variables contienen una acción determinada y estas acciones devuelven o

bien Strings o bien Tablas (algunas acciones no devuelven nada, pero pocas

son las que no lo hacen) y para más tarde poder obtener esa String o Tabla

debemos llamar a las Variables, por eso cada Variable tiene su nombre propio,

pueden haber dos Variables que tengan el mismo nombre, aunque yo no lo

recomiendo si vas a usar las String o Tablas que la variable devuelva, en el

caso de que no quieras utilizar las String que devuelva la variable pues no

importa que hayan varias con el mismo nombre.

Las variables no pueden llamarse de cualquier forma, su nombre tiene que

cumplir unas normas.

Las variables no pueden llamarse: and, end, if, else, elseif, break, for, do, then,

in, repeat, function, or, true, false, in, local, nil, return, table, while, ya que son

nombres reservados para la estructura del script como lo mencione arriba.

Las variables tampoco pueden empezar por un numero ni un signo, solo

pueden empezar por una letra, aunque luego puedes seguir por un numero o

una _ (Guion baja).

Ejemplo de variables inválidas y validas:

24Fuente = una variable invalida

Alucard = una variable valida

For = variable invalida





Ahora les voy a mostrar cómo usar una variable para poder obtener una String

que más tarde utilizaremos

Por ejemplo:

Script

Unidad = Drive.GetFreeSpace(“c:”);

Con eso obtendríamos una String alojada en la variable Unidad que contiene

el espacio libre MB que quedan en la unidad C.

Ahora la aplicaremos a una etiqueta (Label)

Script

Label.SetText(“Lablel1”, Unidad);

Con eso aplicaríamos al Label1 el texto Unidad que corresponde a lo que

Explique anterior mente (espacio libre…)

Para hacerlo solo tenemos que poner en el primer argumento el nombre del

label entre comillas “” y el segundo argumento el nombre de la variable sin

comillas, ya que si llevase comillas sería una String y no una variable.

Y como bien pueden ver ese código no se puede llamar por una variable ya

que no devuelve nada, solo ejecuta una acción.




Practica 1

Practicaremos lo que hemos aprendido en la teoría creando un pequeño reloj

digital.

Pasos

1- Creamos un proyecto nuevo llamado Practica Reloj

2- Vamos a proyecto o Project y en Dimensiones (o Dimensions) es la

primera opción que sale y ahí ponemos 200 de ancho y 100 de alto al

proyecto.

3- Ahora crearemos una Label y ponemos la fuente que más nos guste y la

ponemos en el centro, tirando a la izquierda así como se muestra en la

imagen:

4- Ahora damos 2 clics sobre el fondo de la página y damos a un clic a la

pestaña script, ahí buscamos la pestaña On Timer y nos colocamos

sobre ella así como lo muestro en la imagen:

5- Ahora ponemos ahí el siguiente código:







Script

gh = System.GetTime(TIME_FMT_HOUR)

gm = System.GetTime(TIME_FMT_MIN)

gs = System.GetTime(TIME_FMT_SEC)

Con eso obtendremos la hora, minutos y segundos, alojados cada uno de ellos

en su variable respectiva.

6- Ahora ponemos debajo de ese código el siguiente:

Script

Label.SetText(“Label1”, gh..”:”..gm..”.”..gs);

Con eso aplicaríamos al Label las horas:minutos.Segundos Los .. Sirven para

juntar varias String o strings y variables les deberá haber quedado un código

Así:

7- Ahora activaremos el temporizador, que ejecutara el código de On

Timer cada x tiempo.

Vamos a la pestaña On Preload y ponemos el siguiente código:

Script

Page.StartTimer(1000);





Con eso se ejecutaría a cada segundo, ya que el número de Page.SatartTimer

está en milisegundos.

Aceptamos y probamos nuestro proyecto, como verán funciona perfectamente

y se les vera de la siguiente manera:

Teoría del Script 3 Estructuras de Control

Estructuras de control (if, else, then, etc.)

Las estructuras de control en los scripts es muy útil, y sin ellas poca cosas

podemos hacer…

Por el momento les voy a enseñar a usar el if, else, then, for, do y end.

if, else, then y end









El if y el else son condiciones, es decir, si se cumple un requisito se hace una

cosa, y si no se cumple pues se hace otra cosa.

Un script de ejemplo:

Script

gbt = Button.GetText(“Button1”)

if gbt == “Instalar” then

File.Open(“Autoplay\\Docs\\Setup.exe”, “”, SW_SHOWNORMAL);

else

Dialog.Message(“Noticia”, “El texto del boton no es Instalar.”,

MB_OK, MB_ICONINFORMATION, MB_DEFBUTTON1);

end

Ahora les voy a explicar cómo funciona ese script

1- Obtenemos el texto que lleva el “Button1”.

2- if (si… condición) el texto del botón es == (igual a…) “Instalar” then

(entonces… se hace lo siguiente)

Abrir el archivo “Autoplay\\Docs\\Setup.exe”

else (pero si el texto del botón no es igual a “Instalar”…)

Saldrá un mensaje diciendo que “El texto del botón no es Instalar.”

end (Aquí se acaba el if y el else)

Es fácil aunque no lo parezca, todo es acostumbrarse.

El mismo script funcionaria igual de esta manera:

gbt = Button.GetText(“Button1”)

if gbt == “Instalar” then

File.Open(“Autoplay\\Docs\\Setup.exe”, “”, SW_SHOWNORMAL);

Elseif gbt ~= “Instalar” then

Dialog.Message(“Noticia”, “El texto del boton no es Instalar.”, MB_OK,

MB_ICONINFORMATION, MB_DEFBUTTON1);

end




El único cambio en este script respecto al anterior es que hemos cambiado el

else por elseif gbt ~= “Instalar” then

El elseif gbt ~= “Instalar” then significa esto:

elseif (pero si…) gbt (la variable gbt, que obtiene el texto del boton) ~= (no es

igual a…)

“Instalar” then (entonces…)

Para que lo entiendan un poco mejor, diríjanse a la clase 2 del libro donde

explico los símbolos de relación que podemos usar en los if else y elseif.

Con esto doy por explicada la parte del uso de if, y else.

Ahora dejo otros ejemplos más y unos ejercicios que deben de realizar.

Ejemplo 2

if, else, end, Calcula si eres mayor o menor de edad ingresando Tu nombre y

Edad

Lo que debemos de hacer es agregar los objetos que miramos en la imagen y

colocarles los nombres correspondientes para poder identificarlos rápidamente

a la hora de estar realizando nuestro script.





Una vez hecho eso solo nos queda escribir el siguiente código en el botón

Comprobar en el procedimiento On Click:

Script

--declarando Stings

texto = Input.GetText("inpEdad")

Nombre = Input.GetText("inpTexto")

--declarando Variables

mayor = "Es mayor de Edad"

menor = "Es menor de Edad"

--uso de las condiciones

if texto >= "18" then

Input.SetText("inpresultado", Nombre.." "..mayor)

else

Input.SetText("inpresultado", Nombre.." "..menor)

end

Ahora les voy a explicar cómo funciona ese script

1- --declarando Stings

texto = Input.GetText("inpEdad")

Nombre = Input.GetText("inpTexto")

Esta parte lo que hace es almacenar las strigns que almacenal acciones,

texto = Input.GetText("inpEdad") almacena los valores escritos en la

input de Edad.

Nombre = Input.GetText("inpTexto") almacena los valores escritos en

la input Nombre

2- Las variables mayor = ("Es mayor de Edad"), (menor = "Es menor de

Edad")

Lo que hacen es que almacenan un valor asignado en este caso el texto

que pegara en la input de resultado dado como resultado una oración

comprobando si el personaje ingresado es mayor o menor de edad.

3- if texto >= "18" then

Input.SetText("inpresultado", Nombre.." "..mayor)

else




Input.SetText("inpresultado", Nombre.." "..menor)

end

Pues esta parte lo que hace es comprobar si la edad ingresada es mayor

a 18 años y si lo es realizara la primera acción en caso contrario

realizara la segunda.

Ejercicio

Realice un programa que use if, else, end Usando estas comparaciones Calcula

cual número es mayor.

Para realizar este ejercicio debe de crear un proyecto colocándole por nombre

calcular cual número es mayor, deberá verse como se muestra en la siguiente

imagen:

Script





Probar Valores Numéricos

Otro uso común de la declaración if es probar un valor numérico para ver si

este ha alcanzado cierta cantidad. Para demostrar esto, vamos creando otro

botón que muestre un mensaje después de que hagas Click sobre el 5 veces.

1) Añade a la página un objeto de botón.

No importa cual botón elijas, o en que parte de la página coloques el botón.

Solo necesitamos algo sobre lo cual clickear, de modo que podamos activar un

evento On Click y ejecutar alguna acción.

2) Agrega el siguiente script en el evento On Click del objeto de botón:

nClicks = nClicks + 1;

xButton.SetText(this, "Conteo de clicks: " .. nClicks);

if nClicks > 4 then

Dialog.Message("¡Bravo!", "Hiciste click " .. nClicks .. " veces.");

end





Haz doble Click en el nuevo objeto de botón que añadiste, luego haz Click en

la pestaña script y escribe el script de arriba dentro del evento On Click.

Debería verse así cuando esté terminado:

La primera línea le agrega 1 al valor actual conteniendo en la variable

llamada nClicks. (En el próximo paso le añadiremos algún otro script al

evento On Preload de la página para ajustar esta variable a 0 cuando

se cargue la página).

La segunda línea utiliza una acción xButton.SetText para cambiar el

texto del objeto de botón a ―Conteo de Clicks: n‖, donde n es el valor

actual de nClicks.

La acción xButton.SetText tiene dos parámetros. El primer parámetro

es una cadena conteniendo el nombre del objeto sobre el cual quieres

operar. En este caso, utilizamos la variable especial this, la cual

contiene el nombre del objeto sobre el que es activado el evento On

Click. Básicamente esto es lo mismo que utilizar el nombre del objeto,

tal como lo siguiente.




xButton.SetText(―xButton1‖, ―Conteo de clicks: ― ..nClicks);

El Segundo parámetro de la acción xButton.SetText es una cadena

conteniendo el texto que quieres mostrar en el objeto de botón.

Utilizamos el operador de eslabonamiento para unir el valor actual de

nClicks al final de la cadena ―Conteo de Clicks: ―. Observa que esta

cadena tiene un espacio en blanco al final de ella, así que habrá un

espacio entre los dos puntos (:) y el valor de nClicks. (De este modo,

la cadena resultante se verá mejor).

El operador de eslabonamiento cosiste en dos puntos seguidos (..). De

hecho, con frecuencia es referido como el operador ―punto-punto‖.

Esto es utilizado para unir dos cadenas juntas para formar una nueva

cadena combinada. Es algo así como un ―pegamento‖ de cadenas.

Nota: Técnicamente, el valor interno nClicks no es una cadena (es un

número). Sn embargo, realmente esto no importa. Cuando se hace un

eslabonamiento, AMS automáticamente convierte el número en la

cadena equivalente como se requiere.

El resto del script es solo una declaración if que prueba si el valor

nClicks es más grande que4, y muestra un mensaje cuando esto e4s

verdadero. (Un par más operadores de eslabonamiento son utilizados

en la acción Dialog.Message para crear la cadena de su segundo

parámetro. Observa que también puedes incluir fácilmente el

contenido de una variable ―a la mitad‖ de una cadena).

Una vez que hayas terminado la edición del script On Click del botón,

haz click en aceptar para cerrar el editor de script.




3) Agregamos la siguiente línea en el evento On Preload de la

página:

nClicks = 0;

Necesitamos inicializar nClicks antes de que el botón sea clickeado,

así que nuestro script en el evento On Click del botón iniciara

contando desde 0. Date cuenta que no podemos simplemente ajustar

nClicks a 0 en el evento On Click del botón porque sería reajustado a

cero cada vez que el botón fuera clickeado.

Para añadir una línea al evento On Preload de la página, solo haz

doble Click en la superficie de la página, luego haz Click en la pestaña

On Preload del editor de Script y agrégale la línea nClicks = 0; al script

existente. Una vez que lo hayas hecho, deberá verse así.

4) Previsualiza el proyecto y haz Click 5 veces en el objeto de

botón.

Cada vez que hagas Click en el botón, su texto cambiara para mostrar

cuantas veces has hecho Click sobre él. Después de que hayas




clickeado 5 veces sobre el botón, aparecerá un mensaje diciéndote

que hiciste Click 5 veces.

5) Sal de la vista previa.

Muy bien. Acabas de crear un pequeño programa muy sofisticado.

Consejo Para Tarea: Si quieres aventurarte, intenta si puedes

modificar el script para detener el anuncio del número de clicks una

vez que se haya alcanzado los 10 clickeos.

Te doy una pista: necesitas utilizar un operador lógico como ―or‖ y

―and‖ para probar más de una cosa al mismo tiempo en la condición

de la declaración if. Por ejemplo, podrías hacer que la prueba solo sea

verdadera entre 3 y 7 utilizando una condición como esta:

if (nContar > 2) and (nContar < 8) then --solo es verdadera si es mayor que 2 y menor que 8 end

La segunda línea en el script de arriba es un comentario (el cual

realmente no hace nada). Todo lo que se escriba en una línea

después de dos guiones (--) será completamente ignorado por AMS.

Puedes utilizar tales comentarios cuando quieras añadir notas o

explicaciones ―internas‖ en tus scripts.




Script

Teoría del Script 4 Estructuras de Control Uso de

Ciclo FOR

Algunas veces es útil poder repetir varias veces un montón de

acciones sin tener que escribirlas una y otra vez. Una manera de

lograr esto es utilizando un ciclo for.

La sintaxis básica del ciclo for es:

for variable = start, end, step do

hacer algo aquí end

Por ejemplo:

for n = 10, 100, 1000 do Dialog.Message(―‖, n); end





Este script simplemente cuenta desde 10 hasta 100, de 10 en 10,

mostrando el valor actual de la variable n en un mensaje de cuadro de

dialogo. Esto logra el mismo propósito que si escribes:

Dialog.Message(―‖, 10); Dialog.Message(―‖, 20); Dialog.Message(―‖, 30); Dialog.Message(―‖, 40); Dialog.Message(―‖, 50); Dialog.Message(―‖, 60); Dialog.Message(―‖, 70); Dialog.Message(―‖, 80); Dialog.Message(―‖, 90); Dialog.Message(―‖, 100);

Obviamente, el ciclo for hace mucho más fáciles las acciones de repetición similar. Vamos utilizando un ciclo for sencillo para sumar todo los dígitos entre 1 y 100, y mostrar el resultado.

1) Agrega un objeto de botón en la página. Añade el siguiente script al evento On Click de este botón.

n = 0; for i = 1, 100 do n = n + i; end Dialog.Message(―‖, ―La suma de todos los dígitos es:‖ ..n); El script debería verse así cuando esté terminado:




La primera línea crea una variable llamada n y la ajusta a 0. La

siguiente línea le ordena al ciclo for contar de 1 a 100, almacenando la

―cuenta‖ actual en cada etapa en una variable llamada i.

Durante cada ―paso‖ a través del ciclo, el script entre el ―do‖ y el ―end‖

será ejecutado. En este caso, este consiste en una única lenea que

suma los valores actuales de n y de i, y luego almacena el resultado

de nuevo en n. en otras palabras, le agrega i al valor actual de n.

Este ciclo for es lo mismo que escribir:

n = n + 1; n = n + 2; n = n + 3; n = n + 4; n = n + 5; n = n + 6; n = n + 7; n = n + 8; … hasta llegara 100

La última línea de nuestro script simplemente le muestra al usuario el

resultado del cálculo en un mensaje de cuadro de dialogo.

Consejo: Puedes utilizar el botón Add Code para insertar un ejemplo

de un ciclo for, completando la sintaxis con comentarios explicativos.

Luego puedes editar el ejemplo para ajustarlo a tus propias

necesidades.




2) Previsualiza el proyecto y haz Click en el objeto del botón.

Cuando hagas Click en el objeto de botón, el ciclo for ejecutara a la

velocidad de la luz el cálculo de 100 vedes, y luego la acción

Dialog.Message mostrando el resultado.

Todo esto sucede muy rápido.

3) Sal de la vista previa.

Probablemente no utilizaras los ciclos for con la frecuencia que

utilizaras las declaraciones if, pero definitivamente vale la pena saber

cómo se utilizan. Cuando necesites repetir pasos, estos pueden

ahorrarte mucho esfuerzo.

Por supuesto que cuando hablamos de ahorrar esfuerzo, las

verdaderas campeonas son las funciones.




Teoría del Script 5 Estructuras de Control Uso de for y

do

Con el uso de for y do podemos repetir una acción tantas veces como

queramos añadiendo variables, por lo que con esto es posible de que aunque

sea el mismo código no siempre pase lo mismo al ejecutarlo, bueno mejor les

enseño.

La estructura seria esta.

for nombre_de_la_variable = empezar,acabar,paso do

Aquí iria la acción

end

Y ahora un script de ejemplo para que lo entiendan mejor:

Script

for e = 0,100,1 do

Label.SetText(“Label1”, e);

end

Ese script le daría a la variable “e” un valor distinto cada vez, empezaría en el

0 y acabaría en el 100 yendo de 1 en 1 (el 0 equivale al empezar, el 100 al

acabar, y el 1 al paso) entonces le aplicaría al “Label1” el texto0, luego el 1,

luego el 2 y así sucesivamente hasta llegar al final, en este caso el 100, pueden

hacer el ejemplo pero debo decir que no tiene un tiempo determinado, sino

que hace la acción tan tapido como pueda, por lo que apenas les dará tiempo a

ver los números y verán el 100 cuando acabe.







Práctica 2

En esta práctica vamos a mejorar nuestro reloj, si el que hicimos en la primera

lección.

Esta vez le añadiremos una sencilla opción de despertador.

1- Le añadiremos 1 Input en la parte de abajo y 2 Label que digan H:

(Hora) y M: (Minutos) se deberá ver de la siguiente manera:

2- Y vamos a la pestaña Script en el procedimiento On Timer en donde ya

debemos de tener el scritp del reloj que se vera de la siguiente manera:

Script

gh = System.GetTime(TIME_FMT_HOUR)

gm = System.GetTime(TIME_FMT_MIN)

gs = System.GetTime(TIME_FMT_SEC)

Label.SetText(“Label1”, gh..”:”..gm..”.”..gs);

Ahora debajo de ese código le añadiremos este otro código:

Script

igt1 = Input.GetText(“Input1”);

igt2 = Input.GetText(“Input2”);

if igt1 == gh and igt2 == gm then

Audio.Play(CHANEL_BACKGROUND);

end

Eso obtendría el texto de la “Input1” y lo guardaría en la igt1 y obtendría el

texto de la “Input2” y lo guardaría en igt2, después comprobaría si el texto de





la input1 es igual a la hora y si el input2 es igual a los minutos, de ser así

reproducirá el sonido previamente cargado en la pestaña On Show.

3- Y en la pestaña On Show ponemos esto:

Script

Audio.Load(CHANEL_BACKGROUND, "AutoPlay\\Audio\\Easy

(short).ogg", false, false);

Previamente debemos poner el archivo de audio en la carpeta

Autoplay\Audio, en mi caso copie el archivo Easy (short).ogg en esa

carpeta.

4- Ahora guardamos el proyecto y lo ejecutamos, entonces ponemos la

hora y los minutos en la que queramos que suene y esperamos a que esa

hora llegue, entonces el sonido empezará a sonar, y cuando esa hora

pase el sonido parara (Si lo has puesto a las 22:01, cuando llegue a las

22:02 parara.)

Ejercicio

Para este ejercicio pondremos en práctica el uso de if, or, else, end para

verifica si la letra ingresada es Vocal o Consonante.





El programa deberá verse de la siguiente manera así como se muestra en la

imagen:

En este programa el script que desarrollemos lo colocaremos en el botón

Comprobar en el procedimiento On Click.

1- Escribimos el siguiente script en el botón Comprobar:

--declarando String

texto = Input.GetText("inpTexto")

--uso de las condiciones

if texto == "" then

Input.SetText("inpResultado", "La Caja de Texto esta En

BLANCO")

else

if texto == "a" or texto == "e" or texto == "i" or texto == "o" or texto

== "u" then

Input.SetText("inpResultado", "La letra ingresada es una

VOCAL")

else

Input.SetText("inpResultado", "La letra ingresada es una

CONSONANTE")

end

end





No explicare este script porque lo único nuevo es el uso de or que es (o) y está

comparando el texto escrito en la input si es igual a “a” o “e” o “i” o “o” o “u”

si lo son dirá que es una Vocal y en caso contrario es una Consonante, además

le he agregado una condición extra para que cuando presiones el botón y no

este escrito nada diga que la caja de texto está en blanco.

Ejercicio

Realizar el siguiente programa aplicando lo aprendido en las últimas clases, lo

que se pondrán en práctica serán las estructuras de control y el uso de

variables y strings.

Las estructuras usadas son las de cadena, numéricas, decimales, condicionales.

1- El ejercicio de cadena realizaran un enlace el texto escrito en las dos

Input y las encadenara en la tercera Input.

2- El ejercicio de número realizara una suma de los números escritos en las

dos input y los sumara en la tercera Input.

3- El ejercicio de decimal realizara una suma de los números escritos en

las dos input y los sumara en la tercera Input.

4- El ejercicio condicional realizara una comparación booleana si el

radiobutton seleccionado es verdadero o falso dando una respuesta de la

opción seleccionada en la Input.





El ejercicio deberá verse así como se muestra en las siguientes imágenes.

Script 1

Script 2






Script 3

Script 4




Ejercicio

Este ejercicio trata del Manejo de cajas de texto, manejando las Cajas de

Texto con true y false, lo que ara será habilitar o deshabilitar las cajas de texto

presionando un botón de esa manera tendremos la voluntad de poder agregar

información a ellas o no.

Deberá verse de la manera que se muestra en la imagen, como pueden ver he

agregado 6 Input y 2 botones cada botón realizara una tarea diferente uno

habilitara las Input y el otro las deshabilitara el script que utilizaremos en este

ejercicio es muy sencillo solo usamos los valores booleanos Verdadero o

Falso.

Primero escribimos el script para el botón Habilitar:







Script

Input.SetEnabled("inp1", true)






Eso es todo el script para ese botón lo que hace es habilitar todas las Input.

Ahora aremos el scritp para el botón Deshabilitar:

Script

Input.SetEnabled("inp1", false)






Esto es todo como pueden ver es casi el mismo que el de habilitar pero en este

caso los valores o el segundo argumento es falso eso quiere decir que

deshabilitara las input al darle un Click a dicho boto.




EJERCICIO

En este ejercicio realizaremos una aplicacion que realice diferentes cálculos

matemáticos.

El diseño del formulario deberá tener la siguiente apariencia.

Cuando tengas listo el diseño del formulario ya con sus nombres internos y

ordenados, procederas a crear el script en cada uno de los RadioButtons, el

script deberá colocarce en el procedimiento On Click de cada uno de los

RadioButtons correspondiendo cada script a la operación relacionada, Suma,

Resta, Multiplicacion, Duivision y el resultado deberá imprimierlo en la

Input3.

Nota: La script que deberas de realizar es la aprendida en las lecciones

anteriores solamente cambian los objetos.




Manejo de las Tablas

Las tablas son también muy importantes en la programación, al principio

puede que queramos evitarlas y que nos resulte algo complicado usarlas, pero

en cuanto nos acostumbramos a ellas las usaremos y nos ahorraran varias

líneas de código innecesarias.

Las tablas son como las Strings, pero estas pueden albergar varias líneas a la

vez, algo que resultara muy útil para no tener que trabajar como decenas o

centenas de strings.

Hay varias formas de construir tablas, por ejemplo:

Código:

tablaAlucard = {“uno”, “dos”, “tres”, “cuatro”, “cinco”, “Hola

Alucard”, “Que tal”}

Y después, podríamos llamar a cualquiera de las Strings de esa tabla de esta

manera:

Código:

Llamando = Dialog.Message(“Noticia”, tablaAlucard[6], MB_OK,








Con eso se mostraría un mensaje con la String 6 de la tabla, en este caso la

Sting “Hola Alucard”.

También podemos hacer una tabla así:

Código:

tabladouglas = {};

tabladouglas.uno = “uno”;

tabladouglas.dos = “2”;

tabladouglas.tres3 = “tres”;

Y llamarla de esta forma:

Código:

Llamando = Dialog.Message(“Noticia”, tabladouglas.tres3, MB_OK,


Como ven es muy fácil de albergar muchas strings.

También se pueden obtener tablas de algunas acciones, como por ejemplo:

Código:

Buscar = File.Find(“C:\\MyDir\\”, “*.Docx”, false, false, nil, nil);

De esa manera se obtendrá una tabla que en cada línea estaría la ruta del

archivo (incluyendo el mismo archivo y extensión)

Después podríamos acceder, por ejemplo, al primer archivo encontrado de la

siguiente forma:

Código:

File.Open(buscar[1], “”, SW_SHOWNORMAL);




Global y Event Variables

Autoplay Media Studio viene provisto de variables automatizadas, que se usan para representar valores comunes del sistema, como la ubicación de la carpeta temp del usuario (_TempFolder) o la ruta a Archivos de Programa (_ ProgramFilesFolder). Hay dos tipos de variables incorporadas: Las variables globales‖Global variables‖ que pueden ser usadas en cualquier parte de su proyecto. Las variables de evento ―Event variables‖ que son locales para los acontecimientos. (Sus valores están sólo disponibles para la duración de ese acontecimiento.) Aviso: A menudo las variables son utilizadas como parte de una ruta llena donde usted necesita ensamblar dos Strings. Por ejemplo, usted puede necesitar una ruta que consiste en la carpeta de Archivos de Programa del usuario y una carpeta de programa ―Aplicación X‖. Para hacer esto, usted utilizaría una concatenación entre los strings que consiste en dos puntos (..). El script quedaría así: _ProgramFilesFolder .. \\Aplicacion X Usted También puede usar la acción String.Concat para concatenar dos Stings. Nota: Hay también una serie de acciones disponibles que pueden usarse para recoger información acerca del sistema del usuario que no puede ser parte de la lista de variables incorporadas. Por ejemplo, las





rutas adicionales de las carpetas de usos comunes pueden ser leídas usando la acción Shell.GetFolder. Hay también una categoría del Sistema de acciones para otra información del sistema.

Variables Globales (Global Variables) Las variables globales (o ―las variables incorporadas‖) son variables cuyos valores están automáticamente colocados en el inicio de la aplicación de AMS, se usan para representar valores comunes que podrían diferir entre sistemas. Estas variables son totalmente globales de cual manera que usted las puede usar en cualquier parte de su proyecto. Aviso: Las variables incorporadas se encuentran enumeradas junto con todas las acciones y las constantes cuando usted presiona Ctrl + Space en el editor de script. Todas las variables incorporadas comienzan con una línea subrayada, su usted mecanografía _ y entonces presiona Ctrl + Space, usted vera las primeras variables incorporadas de la lista. Las siguientes variables globales están disponibles en AMS: _AutoTabOrder Esta variable es válida para los siguientes objetos: input, listbox, combobox, radiobutton, checkbox, richtext y tree. Con estas variables puede establecer si quieres que la tecla tabuladora funciona estableciendo true o false en el evento de la página On Key. Estas variables están activadas por defecto así que su uso es para desactivar entre otras cosas.





Ejemplo: _AutoTabOrder = false _CommandLineArgs Una tabla numéricamente indexada que contiene las discusiones de la línea de comando pasó en aplicación Autoplay _DesktopFolder Es la ruta del directorio del escritorio. En Windows NT/2000/XP/Vista/Seven o superior, esta ruta está definida por el perfil del usuario. _DesktopFolderCommon Es la ruta del directorio del escritorio. En Windows NT/2000/XP/Vista/Seven o superior, esta ruta está definida por el perfil del usuario. _DoFlashCheck Una variable Booleana solio controlar aunque AMS revisara en busca del control Flash Player ActiveX en runtime. Si está colocada para verdadero (automáticamente establezca cuando contiene el proyecto un instante el objeto), la comprobación será realizada. Si está colocado para falso, no la comprobación será realizada. Si el cheque es realizado y el control no es encontrado (a base de la versión predeterminada 6.0.0.0), AMS exhibirá un dialogo de notificación. _DoFlashCheck puede ser incrustado en Funciones Globales. _IR_ProductID Esta variable contiene el producto ID del producto de que el escrito fue echado a andar. Esto le deja identificar el producto siendo echado a andar de escrito. Esto podría ser útil al hacer escritos genéricos que son usados en varios productos Indigo Rose, pero eso tiene cosas




diferentes para hacer a base del producto siendo de lo que se escapó. AutoPlay Media Studio 7 devuelve a "AMS70". _NoExitScriptOnPageJump Si el set para escrito verdadero, de acción en un acontecimiento seguirá ejecutado tras un Page.Jump o Page.Navigate que la acción se llama. Si el set para falso, la ejecución de la acción que el escrito en ese momento detendrá tras un Page.Jump o Page.Navigate es llamado. Esta variable es colocada falso por defecto. _ProgramFilesFolder Variable para acceder directamente en el directorio de programs files. _ShowIntroVideo Una variable Boolean usada para el control ya sea el video del intro será exhibida en runtime. Si está colocada para verdadera (por defecto) y el proyecto tiene un intro videograba especificado, el video del intro será mostrado. Si está colocado para falso, el video será saltado. Esta variable debe ser determinada ya sea en Funciones Global, o en el acontecimiento de Arranque. _SoundInitialized Una variable Boolean que se colocó para verdadera si el motor en buen estado exitosamente inicializa en runtime o falso si deja de operar. (El fracaso a inicializar es una ocurrencia muy rara. Esta variable es hecha disponible para esas que pueden requerir esta retroalimentación rara.) _SourceDrive El driver donde se está aplicando el Autoplay [programa] (ej. "C:" o "D:").




_SourceFilename Nombre del archivo de la aplicación de Autoplay (ej. ―autorun.exe‖) _SourceFolder La ruta completa para la carpeta que la aplicación AutoPlay fue ejecutada. (ej. "C:\Downloads" o "D:"). _SystemFolder La ruta del directorio de Windows System (ej. "C:\Windows\System" y C:\Windows\System32"). _tblErrorMessages Una Tabla indexada por el error le pone código a contener todo los posibles mensajes de error. Por ejemplo, acceder al índice de la mesa tblErrorMessages[1000] accederá a la cuerda de código de error "El archivo especificado no podría ser encontrado". El Application.GetLastError que la acción Se usa para recuperar el código de error de la por último acción realizada. _TempFolder La ruta del directorio Temporal ―Temp‖. _WindowsFolder La ruta del directorio de Windows (ej. "C:\Windows").




Variables Globales si usas GlobalPaths Action Plugin

_ExeFolder

Carpeta donde está el programa exe ejecutándose. _AutoPlay La ruta de la carpeta que contiene todos los programas, por defecto la ruta donde están Audio Buttons, Docs,etc.) Nota: El nombre de estas variables pueden ser cambiadas con la acción GlobalPaths.SetDataFolder. _Audio La ruta de carpeta de Audio de programa. _Buttons La ruta de carpeta de Botones de programa. _DLLs La ruta de carpeta de DLLs de programa. . (Nota: esta carpeta no viene creada por defecto y tienes que crearla manualmente para poder usar esta variable). _Docs La ruta de carpeta de Docs de programa.





_Flash La ruta de carpeta de Flash de programa. _Fonts La ruta de carpeta de Fonts de programa. _Icons La ruta de carpeta de Icons de programa. _Images La ruta de carpeta de Imágenes de programa. _Plugins La ruta de carpeta de Plugins de programa. _Scripts La ruta de carpeta de Scripts de programa.

_Video La ruta de carpeta de Video de programa.




Event Variables Algunos acontecimientos en AMS contienen variables cuyos valores están automáticamente colocados cada vez que ese acontecimiento se desencadena. Estas variables son llamadas variables de acontecimiento. Las variables de acontecimiento son locales para el acontecimiento y pueden ser encontradas en algunos la página, diálogo y acontecimientos del objeto. Cuando decimos son "locales," queremos decir que sus valores están sólo disponibles para acciones creadas en ese acontecimiento. Las siguientes variables de acontecimiento están disponibles en AMS:

e_Channel (Tipo: number) El canal de audio cuyo estado tiene, cambió. Esta variable está sólo disponible adelante lo En el acontecimiento de Audio. Uno de los siguientes valores del canal será devuelto:

CONSTANTE VALOR DESCRIPCIÓN

CHANNEL_BACKGROUND 5 Canal de fondo.

CHANNEL_EFFECTS 0 Canal de efectos de sonido.

CHANNEL_NARRATION 6 Canal de narración.

CHANNEL_USER1 1 Canal del usuario 1.




CHANNEL_ALL -3 Todos los canales de audio





e_Checked (Tipo: boolean) True si el objteto tree esta checkado, falso si no está checkeado. Esta variable solo es válida On Check event. e_Column (Tipo: number) La columna (empieza en 0) de la celda ahora tiene foco en el objeto grid. Esta variable es solo valida en objetos grid On Selection Changed event. La columna (empieza en 0) de la celda cambiada en el objeto grid. Esta variable es solo valida en objetos grid On Cell Changed event. e_DialogHeight (Tipo: number) La altura del diálogo actual. Esta variable solo es válida On Size event. e_DialogWidth (Tipo: number) La anchura del diálogo actual. Esta variable solo es válida On Size event. e_Expanded (Tipo: boolean) True si el modo del objeto tree ha sido expandido, false si está colapsado. Esta variable solo es válida On Expanded event. e_FilePath (Tipo: string) La ruta completa para el archivo de imagen a que se cambió en el slideshow. e_FSArgs (Tipo: string) String que contiene el último argumente FSCommand despedido dentro del objeto Flash. Esta variable está sólo disponible On FSCommand event.




e_FSCommand (Tipo: string) String que contiene el último FSCommand despedido dentro del objeto Flash. Esta variable está solo disponible On FSCommand event. e_ID (Tipo: number) Usar la variable e_ID para cargar los aplicaciones del Menú. e_Index (Tipo: number) El índice basado de la diapositiva a que se cambió en el slideshow e_ItemInfo (Tipo: table) La información extendida acerca de la opción del menú actualmente seleccionada.

LLAVE TIPO DESCRIPCIÓN

Text string El texto del menú para interactuar con él.

ID number El ID del objeto del menú para interactuar con él.

IconID number Índice de iconos de la lista de images especificada en la barra de menú. Para Mostrar un icono en el objeto que desees del menú. Empieza en 0,

Enabled boolean True si el menú esta encendido, false si no lo está.

Checked boolean True si el menú esta checkeado, false si no lo es.

e_Key (Tipo: number) El código clave virtual de la llave que se presionó. Esta variable está sólo disponible On Key event. e_Link (Tipo: string) El texto del enlace que se a echo clic. Esta variable es solo valida en On Link event.




e_Max (Tipo: number) El índice de carácter donde el texto del enlace termina. Esta variable está sólo disponible en On Link y On Selection Changed events. e_Min (Tipo: number)

El indice de carácter donde el texto del enlace empieza. Esta variable está sólo disponible en On Link y en On Selection Changed events. e_Modifiers (Tipo: table) Una tabla conteniendo valores de tres boolean que describen cuál el modificador teclea fue sujetado abajo de mientras la llave se apretó. Una llave de modificador es una llave que puede ser mantenida sujeta mientras otra llave se aprieta, "modificarla". Hay tres valores / falsos verdaderos en la mesa, uno para cada quien mecanografían de llave de modificador en el teclado: El desplazamiento, ctrl, y alt. Usted puede lograr acceso a estos valores como e_Modifiers.shift, e_Modifiers.ctrl, and e_Modifiers.alt. Esta variable está sólo disponible solo en On Key event. e_NewText (Tipo: string) El texto que recién ha estado colocado para un modo en el objeto tree . Esta variable está disponible en un objeto tree en On EditLabel event. El texto nuevo de la celda en objeto grid. Esta variable está disponible en un objeto grid en On Cell Changed event. e_NodeIndex (Tipo: string) El índice del modo tree object.




e_OldText (Tipo: string) El texto que existió previamente antes del usuario editó el texto de un nodo en el objeto tree . Esta variable está disponible en un objeto tree en On EditLabel event. El texto que estaba en la celda antes de eso cambió en un objeto cuadriculado. Esta variable está disponible en un objeto grid en On Cell Changed event. e_PageHeight (Tipo: number) La altura de la página actual. Esta variable está sólo disponible en On Size event. e_PageWidth (Tipo: number) La anchura de la página actual. Esta variable está sólo disponible en On Size event. e_Row (Tipo: number) La fila (empieza en el 0 ) de la celda que ahora tiene foco en un objeto grid. Esta variable está disponible en el objeto grid en On Selection Changed event. La fila (empieza en el 0) de la celda que cambió en un objeto grid. Esta variable está disponible en el objeto grid en On Cell Changed event. e_Selection (Tipo: number) El índice de un artículo del comboxbox que está siendo seleccionado. (El primer artículo en la lista tiene un índice de 1.) Esta variable está sólo disponible en On Select event de los combobox.




e_State (Tipo: string) El string conteniendo al estado actual del canal de audio. Esta variable está sólo disponible solo en On Audio event . Uno de los siguientes estados será devuelto:

VALOR TIPO DESCRIPCIÓN

Finish string La pista del canal de audio alcanzado es fin.

Pause string El canal de audio fue pausado usando la acción Audio.Pause.

Play string El canal de audio fue encendido usando la acción Audio.Play.

Stop string El canal de audio fue parado usando la acción Audio.Stop.

e_Type (Tipo: number) El tipo de ajuste el tamaño eso ha ocurrido en On Size event.o el tipo del clic del botón del ratón en On Mouse Button event.On Size e_Type constantes: CONSTANTE VALOR DESCRIPCIÓN

SIZE_RESTORED 0 La aplicación a sido restaurada.

SIZE_MINIMIZED 1 La aplicación fue minimizada a la taskbar.

SIZE_MAXIMIZED 2 La aplicación fue maximizada.

On Mouse Button e_Type constantes:

CONSTANTE VALOR DESCRIPCIÓN

LEFT_BUTTON_DOWN 0 El botón izquierdo del mouse ha sido presionado.

LEFT_BUTTON_UP 1 El botón izquierdo del mouse ha sido soltado.

RIGHT_BUTTON_DOWN 2 El botón derecho del mouse ha sido presionado.

RIGHT_BUTTON_UP 3 El botón derecho del mouse ha sido soltado.

e_URL (Tipo: string) El string conteniendo el URL que ha terminado de cargando o está siendo navegado. Esta variable está sólo disponible en On Loaded y On Navigate events.




e_WindowHeight (Tipo: number) La altura, en pixeles, de la entera ventana de la aplicación, incluyendo el borde y la barra de títulos. Esta variable está sólo disponible solo en On Size event. e_WindowWidth (Tipo: number) La anchura, en pixeles, de la entera ventana de la aplicación, incluyendo el borde y la barra de títulos. Esta variable está sólo disponible solo en On Size event. e_X (Tipo: number) La posición horizontal del cursor del ratón, en pixeles, del lado izquierdo de la página o el diálogo. Esta variable está sólo disponible solo en On Mouse Button y en On Mouse Move events. e_Y (Tipo: number) La posición verstical del cursor del ratón, en pixeles, del lado izquierdo de la página o el diálogo. Esta variable está sólo disponible solo en On Mouse Button y en On Mouse Move events. this (Tipo: string) La String conteniendo el nombre del objeto, la página o el diálogo donde el acontecimiento es hallado. Esta variable es útil para crear acciones genéricas o las funciones que no dependen de nombres de página, dialog, u objeto específico. Por ejemplo: Label.SetVisible (this, false); Esta acción esconde el objeto de la etiqueta en el que fue creado. Por ejemplo, si la acción fuera creada en el objeto denominado "Label1",




escondería el objeto Label1. Si fuera creado en el objeto llamado "Label2", escondería el objeto Label2. Example 1: e_Channel, e_State A menudo es necesario para poder detectar cuándo tiene una pista alcanzó su fin así es que usted puede responder con algún tipo de acción. Este ejemplo ilustra cómo lanzarse a otra página cuando una pista este sonando en el canal de audio de narración alcanza el fin. Usando este diseño, la presentación visual podría ser controlada por una voz de audio encima.

1. Cree un proyecto de dos páginas con su segunda página llamada "Page2".

2. Añada el siguiente código en On Show event de su primera página. Necesitas un archivo de audio para este ejemplo, así es que usted necesitará modificar esta acción así es que carga un archivo real de audio dentro de su proyecto.

-- Carga una pista de audio en el canal de narración. Audio.Load(CHANNEL_NARRATION, "AutoPlay\\Audio\\Lesson1.ogg", true, false); Añade el siguiente codigo en On Audio en la primera página . -- Si el tema del canal de audio de narración llega a su final, salta a otra página. if ((e_Channel == CHANNEL_NARRATION) and (e_State == "Finish")) then Page.Jump("Page2"); end Cargué una pre visualización del proyecto, el archivo de audio se cagara al empezar el proyecto, y cuando termine de sonar cargara la siguiente página.




Example 2: e_Key En la mayoría de los casos, la interacción con una aplicación AutoPlay está consumada usando al ratón. De cualquier forma que cabe también controlar algunos de la funcionabilidad a través del teclado originándose de ciertas claves. Este ejemplo ilustra cómo la navegación puede ser controlada por el teclado si un ratón no está disponible.

1. Crea un proyecto con dos páginas o más. 2. Añada el siguiente código en On Key event ―en todas las

paginas‖.. -- Si el usuario presiona la Tecla Intro ―ENTER‖, salta a la siguiente página del proyecto. if (e_Key == 13) then Page.Navigate(PAGE_NEXT); end Cuando cargues el pre visualización de tu proyecto, cada vez que presione la tecla Intro "Enter", la siguiente página será mostrada.




Creación de Funciones

Una función es sólo una porción de script que puedes definir, nombrar y luego llamar desde cualquier otro lado.

Puedes utilizar funciones para evitar la repetición del mismo script en diferentes lugares, básicamente creando tus propias ―acciones‖ personalizadas (pudiendo completarlas con parámetros y valores de retorno si así lo quieres).

En general, las funciones están definidas como:

function function_name (arguments) function script here return return_value; end

La palabra clave ―function‖ le indica a AutoPlay que lo que sigue es una definición de función. La function_name es simplemente un nombre único para la función. La parte arguments es la lista de parámetros que pueden ser pasados a la función cuando ésta sea llamada. Esta es básicamente una lista de nombres de variable que recibirán los valores que sean pasados. (Las variables resultantes son locales a la función, y sólo tienen significado dentro de ella). Una función puede tener tantos argumentos como quieras (incluso ninguno).

La palabra clave ―return‖ le indica a la función que devuelva uno o más valores al script que la llamó.

La forma más fácil de aprender acerca de las funciones es probar algunos ejemplos, así que sumerjámonos en ello.





1) Elige Project > Global Functions.

Esto abre el cuadro de diálogo Global Functions

El cuadro de diálogo Global Functions es el lugar conveniente para colocar cualquier función o variable que quieras tener disponible a lo largo de todo tu proyecto. Cualquier script que añadas en este cuadro de diálogo será ejecutado cuando tu aplicación sea lanzada, justo antes de que el evento On Startup sea activado.

2) Añade el siguiente script:

function DecirHola(nombre)

Dialog.Message("", "Hola " .. nombre);

end

Cuando hayas terminado, haz click en OK para cerrar el cuadro de diálogo.





Este script define una función llamada DecirHola que toma un solo argumento (el cual hemos llamado ―nombre‖) y muestra un mensaje simple.

Date cuenta que esto solamente define la función. Cuando esté script sea ejecutado, ―cargará‖ la función dentro de la memoria, pero realmente no mostrará el mensaje sino hasta que la función sea llamada.

Deberá verse así cuando lo hayas terminado:

Una vez que has introducido la definición de la función, haz click en Aceptar para cerrar el cuadro de diálogo Global Functions.

3) Añade un objeto de Botón a la página y agrégale este script en su evento On Click:

DecirHola("Douglas");

Este script llama a la función DecirHola que fue definida en el cuadro de diálogo

Global Functions, pasando la cadena ―Douglas‖ como el valor para el parámetro ―nombre‖ de la función.





4) Pre visualiza el proyecto y haz Click en el objeto de Botón.

Cuando haces Click en el objeto de Botón, el script del evento On Click llama a la función DecirHola, la cual entonces muestra su mensaje

Date cuenta que la función DecirNombre fue capaz de utilizar la

cadena que le pasamos y la mostró en el mensaje.

5) Sal de la vista previa. Elige Project > Glovbal Functions y añade

el siguiente script debajo de la función DecirNombre:

function ObtenerNombre()

local nombre = Dialog.Input(―‖, ―¿Cuál es tu nombre?:‖);

return nombre;

end

Cuando lo hayas hecho, haz click en aceptar para cerrar el cuadro de

dialogo.





El resultado final deberá verse como esta imagen:

Este script define una función llamada Obtener Nombre que no toma

ningún parámetro. La primera línea en el interior de la función utiliza

una acción Dialog.Input para mostrar un dialogo de mensaje con un

campo de entrada en el, pidiéndole al usuario que introduzca su

nombre. El calor devuelto de esta acción (es decir, el texto que el

usuario escriba) es entonces almacenado en la variable local llamada

nombre.

La palabra clave ―local‖ hace que la variable solo exista en el interior

de esta función. Es básicamente como decir: ―para el resto de esta

función, en cualquier momento que utilice ―nombre‖, me estoy

refiriendo a una variable local temporal, incluso si hay una variable

global ―nombre‖ la cual es posible que exista‖. El usu de variables

locales dentro de funciones es una buena idea (esto previene que

cambies el valor de una variable global sin tener la intención).

La segunda line en el interior de la función devuelve el valor actual de

la variable local ―nombre‖ al script que llamo la función.




Consejo: De hecho podríamos hacer que este script de la función se

ajuste a una sola línea, lográndose completamente dela variable. En

lugar de almacenar el calor devuelto de la acción Dialog.Input en una

variable, y luego devolver el contenido de esa variable, simplemente

podríamos poner juntas esas dos declaraciones de la siguiente

manera:

function ObtenerNombre()

return Dialog.Input(―‖,¿Cuál es tu nombre?:‖);

end

Esto haría que la función ObtenerNombre retornara el valor que fue

devuelto de la acción Dialog.Input, sin almacenarlo primero en una

variable.

6) Editar el script en el evento On Click del objeto Boton de modo

que, en su ligar, se vea como:

strNombre = ObtenerNombre();

DecirHola(strNombre);

Deberá verse así cuando hayas terminado:




La primera línea llama a nuestra función ObtenerNombre para

solicitarle al usuario su nombre, y luego almacena el valor devuelto de

la variable ObtenerNombre en una variable llamara strNombre.

La siguiente línea pasa el valor en strNombre a nuestra función

DecirlHola.

7) Previsualiza el proyecto. Prueba el script haciendo Click en el

objeto del botón.

Cuando hagas Click en el objeto de Botón, un cuadro de dialogo de

entrada aparecerá pidiéndote introducir tu nombre.

Después de que escribas tu nombre y hagas Click en Ok (o

presionas Enter, una segundo cuadro de dialogo aparecerá,

saludándote con el nombre que introdujiste.




¿Fantástico verdad?

8) Sal de la vista previa. Edita el script en ese mismo evento On

Click del objeto de botón de tal manera que se vea como:

DecirHola(ObtenerNombre());

Esta versión de script elimina por completo la variable strNombre.

En lugar de eso, utiliza el valor devuelto de la función

ObtenerNombre como el argumento para la función DecirHola.

En otras palabras, pasa el valor devuelto de la función

ObtenerNombre directamente a la función DecirHola.

Cuando una función devuelve un valor, puede utilizar una llamada

de la función de la misma forma que si utilizaras el valor, o una

variable que contiene el valor. Esto te permite utilizar el valor

devuelto de una función sin tener que proponer un nombre único

para una variable temporal.

9) Previsualiza el proyecto y de nuevo priva el script. Cuando hayas

terminado, sal de la vista previa.

El script deberá trabajar exactamente igual que antes: se te preguntara

tu nombre y luego serás saludado con él.

Este es solo un ejemplo sencillo, pero te dará una idea de lo

increíblemente poderosas que son las características de la funciones.

Con ellas puedes condensar grandes piezas de script dentro de

simples llamadas de función, las cuales son mucho más fáciles de

escribir y te dan una sencilla localización central para hacerle cambios

a ese script. También te permite crear flexibles ―subrutinas‖ que




aceptan diferentes parámetros y devuelven resultados, igual que las

acciones incorporadas en AMS.

Y a pesar de todo ese poder, son realmente muy sencillas de utilizar.

Ejercicio

Esta función nos da el Día y la Fecha es muy buena a la hora de

realizar tareas como el reloj, aquí dejo el script.

Script

--función DIA FECHA

function myDayDate() sDay = System.GetDate(DATE_FMT_DAYOFWEEK); tDayName={}; tDayName[1] = "Lunes"; tDayName[2] = "Martes"; tDayName[3] = "Miercoles"; tDayName[4] = "Jueves"; tDayName[5] = "Viernes"; tDayName[6] = "Sabado"; tDayName[7] = "Domingo"; nDay = String.ToNumber(sDay); -- porque System.GetDate como resultado una cadena if nDay ==1 then sDayName=tDayName[1]; elseif nDay ==2 then sDayName=tDayName[2]; elseif nDay ==3 then sDayName=tDayName[3]; elseif nDay ==4 then sDayName=tDayName[4]; elseif nDay ==5 then sDayName=tDayName[5]; elseif nDay ==6 then sDayName=tDayName[6]; elseif nDay ==7 then sDayName=tDayName[7]; end sDate = System.GetDate(DATE_FMT_EUROPE);




Label.SetText("Date", sDayName..", "..sDate); end

Uso y Creación de las Máscaras

Las máscaras son una herramienta muy importante en el desarrollo de

software en AMS ya que te dan la flexibilidad de poder definir el tipo de

información que puedes agregar en dichos objetos de una manera

muy fácil y rápida.

Sabemos que si no usamos Bases de datos en AMS no podemos

definir directamente el tipo de campo de una caja de texto pero gracias

a la función de aplicación de máscaras de AMS podemos definir esto

de una manera muy práctica.

Ejemplo de máscaras básicas.

(###): Esta mascara lo que logra es que en una caja de texto (input)

solo podamos escribir 3 dígitos en este caso números que quedaran

de la siguiente manera (123).

##/##/####: Esta mascara lo que logra es que una caja de texto

(Input) solo podamos escribir fechas ordenadas de la siguiente manera

DD/MM/AAAA o MM/DD/AAAA.





#?#?: Esta mascara nos permite agregar 4 dígitos 2 numéricos y 2

alfanuméricos se vera de la siguiente manera 1a2b

Nosotros podemos crear nuestras propias máscaras, no solo usar las

que trae por defecto AMS lo que debemos de haces es acceder a las

propiedades de nuestra Input y dirigirnos a la pestaña Settings, una

vez colocados en la esta pestaña buscamos la siguiente opción:

Una vez ubicados en este parte de la pestaña seleccionamos la opción

Input mask para poder acceder al botón de options… ―opciones‖ para

poder elegir entre las máscaras por defecto o crear nuestra mascara

personalizada.

Cuando demos un Click sobre el botón de opciones nos aparecerá un

panel como el que se muestra en la siguiente imagen:




Dentro de este panel está el ComboBox el cual contiene las máscaras

por defecto las cuales son las siguientes:

Estas mascaras son muy básicas les explicare en clase para que son

las máscaras que se muestran en este panel pero no es muy difícil

deducir para que se utilizaran.

Aparte de tener estas 6 opciones podemos hacer más nosotros claro

que no se almacenaran en la memoria de AMS para que siempre

estén en la lista solo estará disponible en la Caja de texto aplicada.

Como podemos crear nuestra mascara personalizada.

El ComboBox normalmente tiene una apariencia como esta:

Como te percataras el combobox de las máscaras es diferente tiene

una apariencia como esta.





Eso quiere decir el ComboBox de las máscaras no es una Input si no

que es un Combobox Editable, lo cual hace que podamos escribir

nosotros mismos las máscaras que queramos.

Explico el funcionamiento de la creación de máscaras.

#: Indica que es un Carácter Numérico, dependiendo la cantidad de

veces que lo repitamos será la cantidad de caracteres que soportara la

Input por ejemplo:

Quiero una input que solo pueda escribir 10 Caracteres lo que debo de

hacer es lo siguiente:

##########

Como podemos ver solo e agregado al ComboBox 10 símbolos de

número y he logrado crear una máscara que solo me admita 10

caracteres numéricos.

Ahora como logramos hacer que una Input admita solo letras y un

número determinado de ellas.

?: Este signo de interrogación lo que logra hacer en la opción de

creación de máscaras es definir un valor alfanumérico a nuestra input

sin importar la cantidad de veces que lo repitamos cada signo de estos

―?‖ definirá un carácter al igual que el ―#‖ define un numero el ―?‖

define una letra.

Ejemplo de uso:

Digamos que estamos creando un campo en el cual queremos colocar

el nombre de una persona la cual su nombre solo consta de 7

caracteres y solo ese nombre debe de escribirse en esa caja de texto

cual sería la máscara adecuada para ello:




???????

Esta sería la máscara una vez ejecutada se vería de la siguiente

manera

Como pueden ver sola mente se pudieron digitar 7 caracteres y los 7

son alfanuméricos.

De esa manera se logran crear mascaras básicas pero todo depende

de nuestras necesidades podemos crear todo tipo de máscaras como

por ejemplo una máscara para colocar direcciones IP o Una máscara

para colocar Contraseñas entre muchas cosas más.

Practica:

Desarrolle el siguiente ejercicio de máscaras de la manera que usted

mejor crea conveniente. Las máscaras que se le solicitan se muestran

en la siguiente captura.





Una vez creadas las máscaras ejecute su aplicación y deberá verse de

la siguiente manera al haber agregado los datos que se requieren en

cada una de las máscaras creadas.

Deberá verse de la siguiente manera:

Ahora escriba cada una de las máscaras para verificar su trabajo:

Mascara numérica de 10 caracteres:

Mascara alfanumérica de 10 caracteres:




Mascara de fecha mm/dd/aaaa:

Mascara serial de Sistema Operativo Windows:

Mascara número telefónico:

Esto es el uso de las máscaras y como pueden ver son muy útiles en

el desarrollo de programas y aplicaciones básicas.

Ejercicio

Cree el siguiente programa usando las máscaras que se muestran en

la imagen de abajo y desarrolle las máscaras para cada una de las

cajas de texto en la parte inferior de este ejercicio:

La máscara de producto tiene la capacidad de almacenar 30

caracteres, esos son los únicos datos a seguir.




Mascaras

Producto:

Fecha Ingreso:

Fecha Salida:

Valor Costo:

Valor Venta:

Utilidad:




USO DE LOS MENUS

Los menús en AMS son igual que en cualquier otro software de

desarrollo con la ventaja que es este lenguaje son más fáciles de crear

y entender.

Entre algunas ventajas que nos dan los menús tenesmos los accesos

rápidos a las opciones de los programas que estemos desarrollando, y

no menos importante la estética que le dan los menús a los programas

ya que la mayor parte de por no decir todos los programas del

mercado constan de las barras de menús no solo por estética sino

también por necesidad.

Hay distintos tipos de menús los desplegables y los de pestañas, yo

les enseñare en esta parte del tema como desarrollar menús

desplegables los tradicionales, más a delante veremos cómo

desarrollar menús con pestañas.

¿Qué es un menú?

Es una barra en la cual se alojan diversas opciones de un programa,

ordenadas por categorías, dentro de cada categoría se encuentran

una serie de opciones las cuales ejecutan acciones que están





previamente programadas por el desarrollador del programa. Algunos

ejemplos de las barras de menús son los menús de AMS:

Como pueden ver este menú está compuesto por 11 categorías y cada

una de ellas tiene una serie de opciones, en este capítulo

aprenderemos a realizar menús como estos.

¿Cómo agregar un menú a nuestro programa?

Lo primero que debemos de hacer es crear un nuevo proyecto el cual

le pondremos por nombre pruebas de menús.

Luego de haber creado nuestro proyecto procedemos a la opción

Project - Menú Barr… Una vez que hayamos dado Click sobre ella

nos mostrara la siguiente ventana:




En esta ventana podremos configurar nuestro menú de la manera que

mejor nos convenga, para activar los menús debemos de activar la

casilla de selección llamada Show menú bar, una vez que la hayamos

activado podremos iniciar con la elaboración de las categorías y

opciones de los menús cuando lo tengamos activado veremos el panel

centrar de nuestra ventana de configuración de la siguiente manera:

Una vez que tenemos las propiedades de esta manera podremos

editar el texto de las categorías de ejemplo y crear nuestras propias

categorías, para ello debemos de dar doble Click sobre ellas o

seleccionarla y presionar el botón de propiedades que se encuentra en

la parte inferior de este mismo panel de configuración. Una vez que

estemos en las propiedades de una de las categorías veremos el

siguiente cuadro de opciones:




En esta ventana de propiedades tienes las siguientes opciones las

cuales son muy importantes manejarlas adecuadamente ya que de

ello depende el buen funcionamiento de los menús.

Menú ID: esta es una de las opciones muy importantes al momento de

estar desarrollando los menús ya que esta es la opción que le da un

nombre a cada una de las categorías y opciones de nuestro menú,

como podemos apreciar en la imagen superior el ID es 100 eso quiere

decir que cuando estemos desarrollando el script cuando queramos

llamar a esta opción debemos de colocar el nuero 100 y de esa

manera para cada una de las opciones del menú.

Lo recomendable es que manejemos un rango de números por

categorías como por ejemplo:

Si queremos que la primera opción del menú sea Archivo y dentro de

ella se encuentren 5 opciones más las cuales serán: Guardar,

Guardar Como, Abrir, Imprimir, Cerrar.

Esto nos da un total de 6 opciones las cuales las crearemos de la

siguiente manera.

Primero creamos la opción madre o principal en este caso sería

Archivo, y luego dentro de ella crear las sub opciones, deberá verse de

esta manera cuando esté terminado:




Para ello debemos de crear un rango yo para la categoría Archivo

creare un rango de 1 a 99 el cual se conformara de la siguiente

manera:

Nombre Opción ID

Archivo 1

Guardar 2

Guardar Como 3

Abrir 4

Imprimir 5

Cerrar 6

De esa mara los podremos identificar más rápidamente a la hora de

ocuparlos en el desarrollo de los script.

Ahora explico cómo agregar más opciones a nuestros menús y como

crear los separadores dentro de ellas.

Primero que nada debemos colocarle un nombre a la opción madre o

principal luego de ello procedemos a crear sus sub categorías las

cuales las agregamos teniendo seleccionada la primera opción a si

como se muestra en la siguiente imagen:

Cuando tengamos seleccionada la categoría procedemos a dar un

Click al botón llamado ADD que se encuentra ubicado en la parte

inferior de nuestro panel de configuración:

Una vez que demos Click nos abrirá una nueva ventana en la cual

colocaremos nuestras sub categorías así como se muestra en la

imagen:




Como pueden ver al crear una sub categoría el Menú ID adopta el

correlativo del nuero colocado en la opción principal del menú, luego

de ello en la Caja de texto llamada Text colocaremos el nombre que

queramos que tenga nuestra opción y en la cajas de selección

inferiores podemos elegir el estado y tipo de opción que ocupemos,

aparece seleccionada por defecto la opción Enabled la cual hace que

nuestras opciones estén habilitadas al desplegar el menú, la siguiente

opción Checked hace que nuestras opciones de menú tengan la

capacidad de ser seleccionables para poder seleccionar distintas

opciones a la vez, y la última Separator la función que brinda es crear

líneas separadoras dentro de una misma categoría para poder

manejar de una manera ordenada nuestros menús.

Ejemplo de cómo quedaría un menú con dos categorías:




Ahora comenzaremos a desarrollar un script básico para los menus

crearemos un menú que haga tareas básicas como minimizar,

maximizar y cerrar para ello crearemos una categoría de menú y la

llamaremos opciones de control

Deberá verse así:

Ahora procedemos a desarrollar el script para que cada una de estas

opciones funcione correctamente.

Una vez creada las opciones nos dirigimos a las propiedades de

nuestra hoja de trabajo y nos dirigimos a la pestaña Script una vez

dentro de esa pestaña seleccionamos la opción On Menú y dentro de

ella se colocara los script correspondientes para cada una de las

opciones del menú.




Script

if e_ID == 2 then Window.Minimize(Application.GetWndHandle()); else if e_ID == 3 then Window.Maximize(Application.GetWndHandle()); else if e_ID == 4 then Window.Close(Application.GetWndHandle(), CLOSEWND_SENDMESSAGE); end end end

Este es el script que hará que nuestro menú funcione correctamente ahora procedo a explicar brevemente el funcionamiento de este script: Como podemos apreciar estamos usando un formato condicional en el script que si una condición se cumple realice cierta acción en caso contrario realice otra y así sucesivamente, la palabra e_ID es la variable que se le ha asignado a las opciones del menú. De esta manera podremos crear nuestro menús como pudieron ver es muy fácil de crearlos ahora solo depende de la imaginación de cada uno de ustedes para desarrollar mejores menús. Ejercicios Cree un programa el cual solo funcione con menús que tenga 4 categorías y que cada una de ellas tenga 6 opciones, usted decidirá de que quiera hacer el programa, pero deberá desarrollar el script en el libro:




Script




BASES DE DATOS EN SQLite Las bases de datos son una de las herramientas más poderosas en el desarrollo de software ya que con ellas podemos crear una gran cantidad de aplicaciones que almacenen todo tipo de información sin temor a perderla, con las bases de datos en SQLite podremos crear una gran cantidad de software de todo tipo, sin importar su categoría. Con las Bases de Datos en SQLite tenemos una gran ventaja a la hora de guardar nuestra información ya que son unas de las bases de datos más seguras y estables, podremos estar sin temor a que se nos corrompan fácil mente y perder toda la información en ellas guardadas, aparte de ello como su nombre lo dice son bases de datos SQL de una manera más flexible y rápida de manejar. Todos sabemos que las bases de datos en SQL se usan más que todo para programas que se manejan en Redes, el las Web y aplicaciones de gran calidad un ejemplo de ellas las Bases de datos que manejan los software para las aduanas son en SQL, las de las páginas web tales como FACEBOOK, GOOGLE, YOUTUBE, sus bases de datos están creadas en SQL, y nosotros aprenderemos a manejar un derivado de SQL llamado SQLite, no por ello deja de ser potente al contrario es igualmente potente con la ventaja que lo podemos manejar rápidamente con AMS.





Para crear una Base de datos en AMS debemos de tener primero bien claro lo que queremos hacer en este caso crearemos un programa que nos almacene Un nombre y una Contraseña. En una base de datos podemos crear todas las tablas que nosotros queramos ya que una base de datos es un contenedor de tablas, las tablas son las que tendrán los campos que queremos usar, y las que almacenaran la información agregada por medio de nuestro programa, para crear una tabla primero debemos de crear una base de datos.

SQLite - Extensiones del Lenguaje SQL

SQLite proporciona una serie de mejoras en el lenguaje SQL, que no

se encuentran normalmente en otros Motores de Bases de Datos,

sean comerciales o no. SQLite provee declaraciones como REPLACE

y ON CONFLICT, clausulas que permiten añadir para el control de la

limitación de resolución de conflicto.

SQLite soporta ATTACH y DETACH, que son comando que permiten

a múltiple Bases de Datos independientes sean utilizadas en una

misma consulta. Por último SQLite define las API que permite al

usuario añadir nuevas funciones SQL y el cotejo de las secuencia.

SQLite - De código Legible

El código fuente de SQLite estás diseñado y codificado para ser

legible y accesible hasta para un programador medio. Todos sus

procedimientos, estructuras de datos y variables están

cuidadosamente comentadas con información útil e integral para que

de esa forma se pueda comprender su estructura y el significado de

cada una de las partes de la aplicación.


http://sqlite-latino.blogspot.com/2007/11/sqlite-extensiones-del-lenguaje-sql.html

http://sqlite-latino.blogspot.com/2007/11/sqlite-de-cdigo-legible.html



SQLite - Registros de Longitud Variable

La mayoría de los motores de Bases de Datos SQL, asignan una

cantidad fija de espacio en disco para cada fila en la mayoría de los

Campos de una determinada Tabla. Tomemos un clásico ejemplo para

entender este concepto sencillo, tomemos un Campo de tipo

VARCHAR(100), esto significa que el motor de Base de Datos

asignará 100 Bytes de espacio en disco fijo, independientemente de la

cantidad de de información que se almacene en ese Campo.

SQLite por el contrario, utiliza únicamente la cantidad de espacio de

disco necesario para almacenar realmente la información en ese

Campo. Tomando el ejemplo anterior, si quisiera almacenar un solo

caracter en un Campo definido como VARCHAR(100), entonces solo

un único byte de espacio de disco se consume, realmente una

característica especial para ahorrar espacios en memorias.

El uso de registros de Longitud Variable por SQLite, tiene una serie de

ventajas, entre ellas el resultado de un pequeño archivo de Base de

Datos. También hace que la Base de Datos funcione más

rápidamente, debido a que hay menos información desperdiciada que

leer y recorrer.


http://sqlite-latino.blogspot.com/2007/11/sqlite-registros-de-longitud-variable.html




SQLite - Tipado Dinámico

La mayoría de los Motores de Bases de Datos SQL utilizan un tipado

estático de datos. ¿Qué significa esto? Un dato se asocia con cada

columna de una tabla de valores y solo ese tipo de dato se permite

almacenar en esa columna. SQLite, por el contrario rompe con este

pensamiento, imponiendo el concepto del Tipado Dinámico, diciendo

que el dato es un valor de la propiedad en sí, no de la columna en la

que se va a almacenar el valor.

Por lo tanto SQLite permite al usuario almacenar cualquier valor de

cualquier dato en cualquier columna, independientemente de la

declaración del tipo de la columna.

El uso de este nuevo concepto fue una deliberada decisión de diseño

que ha demostrado en la práctica ser más fiable y más fácil de usar,

especialmente cuando se utilizan en combinación con lenguajes de

programación como Python, Ruby, Tcl entre otros que implementan

estas características desde sus inicios.


http://sqlite-latino.blogspot.com/2007/11/sqlite-tipado-dinmico.html



SQLite - Compacto

Cuando se pensó en optimizar el código SQLite en cuanto a su

tamaño, toda la librería funcional es menor de 225 KiB (medido en una

ix86 utilizando el tamaño de utilidad del compilador GNU), de este

modo es posible desactivar en tiempo de compilación numerosas

características innecesarias para poder reducir aún más el tamaño de

la biblioteca llegando mas o menos a 170 KiB.

La mayoría de otros motores de Bases de Datos SQL, son

muchísimos mas grandes que este. Inclusos motores de Bases de

Datos sin todas las características y las funcionalidades e inclusives

comprimidos son el doble de pesados que SQLite.

SQLite - Único archivo de Base de Datos


http://sqlite-latino.blogspot.com/2007/11/sqlite-compacto.html

http://sqlite-latino.blogspot.com/2007/11/sqlite-nico-archivo-de-base-de-datos.html





Una Base de Datos SQLite es un único archivo de disco ordinario y

que además puede estar situado en cualquier parte del directorio

dentro de las jerarquías de directorios. Esto trae como ventaja que el

archivo de Base de Datos puede ser fácilmente copiado en algún

dispositivo de memoria por ejemplo en USB o por correo electrónico.

Otros motores de Bases de Datos tienden por lo general a almacenar

gran cantidad o colección de archivos, que solo el motor de la Base de

Datos puede llegar a tener acceso a las mismas, esto hace que los

datos sean más seguros y más difíciles de acceder.

Algunos motores de Base de Datos SQL proporcionan la opción de

escribir directamente en el disco y pasar por el sistema de ficheros

todos juntos. Esto aporta una mayor rendimiento, pero a costa de una

considerable complejidad de instalación y mantenimiento.

SQLite - Serverless

La mayoría de los motores de base de datos SQL se ejecutan como

un proceso separado del servidor. Los programas que quieren acceder

a la base de datos para comunicarse con el servidor mediante el uso

de algún tipo de comunicación (normalmente TCP/IP) para enviar

peticiones al servidor y recibir de vuelta los resultados. Entendido esto

podemos decir que SQLite no trabaja de esa manera. Con SQLite, el

proceso que quiere acceder a la base de datos lee y escribe

directamente de los archivos de base de datos en el disco. No existe

un intermediario proceso servidor.

Existe muchas ventajas y desventajas con respecto a los servidores,

La principal ventaja es que no existe ningún proceso de instalación de

servidor, como así también su configuración, inicialización, etc. Por

ello es una de las razones por la cuanl SQLite - Configuración [0].

Cualquier programa que sea capaz de acceder al disco se puede

utilizar una base de datos SQLite.


http://http/elcodigok.blogspot.com/search/label/Bases%20de%20Datos

http://elcodigok.blogspot.com/search/label/Bases%20de%20Datos




http://http/elcodigok.blogspot.com/search/label/Bases%20de%20Datos

http://sqlite-latino.blogspot.com/2007/11/sqlite-serverless.html

http://sqlite-latino.blogspot.com/2007/10/sqlite-configuracin-0.html



Por otro lado, un motor de base de datos que utiliza un servidor puede

proporcionar una mejor protección frente a fallos en la aplicación del

cliente - se dirige a los punteros en un cliente no puede corromper la

memoria en el servidor.

La mayoría de los motores de base de datos SQL son cliente/servidor.

De los que son servidores, SQLite es el único que sabe de este autor

que permite que múltiples aplicaciones puedan acceder a la misma

base de datos al mismo tiempo.

Algunas preguntas sobre SQLite

¿Que es SQLite?

SQLIte es una nueva generacion de Motores de Base Datos llamados,

Seudo-Motores. O configuracion, Mas Rapido Usar- Vease

SeudoMotores.

¿Que tipo de Licencia tiene SQLite?

Dominio Publico - Permite usarlos en productos comeciales y no

comerciales.

¿Que tipo de aplicacion esta Orientado SQLite - Alta, Mediana,

Baja?

SQLite esta destinado a cualquir tipo de aplicacion, medianas o Semi

Complejas ej aplicacioes desktop, bibliotecas, padrones, respaldo de

datos, web site.

¿Que tamaño max puede tener una Base de datos con SQLite?

2 Tb – TeraBytes.




¿Que tamaño max puede tener una tabla de datos con SQLite?

1 Gb. -GigaByte.

¿SQLite soporta multiUsuarios?

Puden haber varios, usuarios accediendo simultaneamente a la DB

pero solo uno podra escribir en un instante de tiempo, posee un

sistema um lock, el cual nos dira si se encuntra ocupado atraves del

mensaje SQLITE_BUSY

¿SQLite Vs Oracles, Posgrest, MySql, FireBird?

Podemos sitar e algunas de sus ventajas,

NO tener que esta instalado un servidor de base datos,

NO existe una arquitectura cliente/servidor

Insersiones, Modificaciones, Eliminacion 8 veces mas Rapidas

Facil de Usar

¿Desventaja de SQLite?

No Poser Itegridad referecial -No portada Aun -

Pocas comunidades de usarios

¿SQLite Soporta datos tipo BLOB?

Desde la version 3, podemos asigar este tipo de datos.

Para los que no estan muy familiarizados con el tema los BLOB

(Binary Large OBjects, grandes objetos binarios), son elementos

utilizados en las Bases de Datos para almacenar datos de gran

tamaño que cambian de forma dinámica.

¿SQLite esta escrito en?

Esta escrito en el Lenguaje de Programación C++

¿SQLite con que Lenjuage puedo utilizarlo?

Podemos hace uso de estos lenguajes:

Java, Groovy, Python, C++, Ruby, Tcl, etc.


http://elcodigok.blogspot.com/search/label/C%2FC%2B%2B



La base de datos que crearemos le pondremos por nombre: Nombre Base de Datos: Messenger Nombre de la Tabla: Usuario Una vez que tenemos claros los nombres de la Base de datos y la tabla, verificamos los campos que ocupas los cuales son: Campos Tabla Usuarios: Nombre, Contraseña Cuando ya tenemos toda esta información recolectada procedemos a crear nuestra Base de datos y tabla para ello crearemos un nuevo proyecto al cual le pondremos por nombre Contenedor. Cuando ya tengamos el proyecto creado procederemos a darle las dimensiones adecuadas a nuestro programa, las cuales deberán quedar de la siguiente manera: Cuando ya tengamos esto listo procedemos a crear nuestra Base de Datos y Tabla, para ello nos dirigimos a la barra de menú en la opción Project – actions…




Una vez que demos Click en Actions nos aparecerá la siguiente

ventana:

En esta ventana es en la que crearemos nuestra DB y Tabla, para ello

comenzamos a desarrollar el script.

Creamos una búsqueda para la base de datos en el directorio que la

crearemos al inicio para que cuando iniciemos el programa busque

primero si existe la tabla y si existe solamente abrirla de lo contrario

creara una nueva.

La ruta en la que guardaremos nuestra base de datos será en el

directorio Autoplay\\Docs ya que este directorio siempre está en

nuestro programa y no tendremos problema al buscar nuestra base de

datos.




Script para buscar la base de datos:

sDatabaseFile = _SourceFolder.. "\\Autoplay\\Docs\\Messenger.db";

Esta parte es la que realiza la búsqueda y si existe la abrirá y si no la

creara.

En caso de que la encuentre ejecutara la siguiente línea.

db = SQLite.Open(sDatabaseFile);

Lo que hace esto es abrir la base de datos pero si da algún tipo de error en

la apertura deberemos hacer que nos notifique el erro para ello colocamos

el siguiente código.

nLastError = Application.GetLastError()

if nLastError ~= SQLite.OK then

Dialog.Message("Error Apertura de DB", SQLite.GetLastErrorString());

end

Aquí lo que ara será leer la aplicación y vera si hay un erro y si lo hay

mandara un mensaje de error que dirá Error de apertura de base de datos y

nos dirá cuál es el error que hemos tenido.

Todo esto es si la base de datos existe ahora si no existe debemos de

crearla para ello ocupamos el siguiente Script.

SQLite.Query(db, "CREATE Table Usuario(RecordID integer primery

key, nombre text, contrasena text)");

Este script lo que hace es crear una base de datos con su respectiva tabla,

SQLite.Query es el comando para crear una base de datos db es la

variable de la base de datos, CREATE Table creara la tabla dentro de la

base de datos la cual tiene por nombre Usuario ahora RecordID sería el

campo llave o índice ascendente de nuestra tabla el cual agregara un

numero único a cada registro lo cual lo hace esta parte: integer primery




key el resto del script son los campos de la tabla se agrega el campo y tipo

de campo que será en este caso text aunque la mayor parte de veces

usamos este tipo de campo y luego con las máscaras de los objetos

creamos las definiciones para cada tipo de campo si es numérico, fecha,

moneda, hora, etc.

Cuando tenemos todo esto junto en la venta de acción nos quedara algo así

como esto:

Script

sDatabaseFile = _SourceFolder.. "\\Autoplay\\Docs\\Messenger.db";





end

SQLite.Query(db, "CREATE Table Usuario(RecordID integer primery key, usuario text, contrasena

text)");

Imagen:

La base de datos la creamos en el procedimiento On StartUp ya que se

debe de ejecutar al iniciar el programa.




Luego de que tengamos listo lo de la base de datos procedemos a agregar

los objetos a nuestro programa para ello debemos de tomar en cuenta de

que es trata nuestro programa y agregar los objetos adecuados.

Tenemos dos campos que ambos son de introducción de texto por lo tanto

ocupamos 2 cajas de texto y dos etiquetas que hagan referencia a lo que se

digitara en las cajas de texto, luego de ello ocupamos un botón para guardar

nuestro datos y un botón para cancelar, y uno para iniciar el programa por lo

tanto ocupamos 3 botones.

2 Input 2 Etiquetas 3 Botones Cuando tengamos agregado los objetos deberán verse de la siguiente manera:




Cuando tengamos esto listo debemos de colocarles nombres a los objetos

esto es para que cuando los estemos relacionando con el script del

programa sepamos hacerlo más ordenadamente.

Para ello nos dirigimos a cada uno de los objetos entrando en las

propiedades de ellos y ubicándonos en la pestaña Attributes, Luego en esa

pestaña en la parte inferior veremos una serie de opciones y nosotros

buscaremos la que dice Object name en ella es donde colocaremos los

nombres de los objetos por ejemplo accedo a las propiedades de la input1

la cual corresponde al campo nombre, entonces deberá colocarle un

nombre de acuerdo a el campo pero aparte de ello le agregaremos un

prefijo ya que cada objeto tiene un prefijo único en el caso de las cajas de

texto es INP y el de los botones es BTN le colocaremos por nombre

inp_nombre cuando le hallamos colocado el nombre le damos al botón

aceptar y listo seguimos con los demás objetos al finalizar de hacer eso

procedemos con el desarrollo del script.

Antes de iniciar a crear el script del programa debemos de activar el plugins

de SQLite para ello nos dirigimos a la barra de menú en la opción Project –

Plugins y damos un Click sobre ella nos abrirá una ventana a si como esta:




Cuando nos abra esta venta seleccionaremos la casilla de SQLite así como

se muestra en la imagen y le damos Click al botón OK y listo procedemos a

desarrollar nuestro Script.

Entraremos a las propiedades de la hoja de nuestro proyecto y nos

dirigiremos a la pestaña de script y en el procedimiento On Preload,

colocaremos el script.

Script

if bNewRecord then

Input.SetText("inp_nombre", "")

Input.SetText("inp_contrasena", "")

else

tInfo_Selected = SQLite.QueryToTable(db, "Select * from Usuario where RecordID="..nRecordID)

nRecordID = tInfo_Selected.Data[1]["RecordID"]

sNombre = tInfo_Selected.Data[1]["Nombre"]

sContrasena= tInfo_Selected.Data[1]["Contrasena"]

Input.SetText("inp_nombre", sNombre)

Input.SetText("inp_contrasena", sContrasena)

end

Bueno pues en este script lo que hacemos es declarar los campos junto con

los objetos correspondientes usando un formato condicional.

Esta parte:

Input.SetText("inp_nombre", "")

Input.SetText("inp_contrasena", "")




Lo que hace es limpiar las cajas de texto al iniciar el programa. Luego de ello se ejecuta la declaración de variables para los campos de la tabla y al final se declaran los objetos junto con los campos que les corresponden. El script terminado deberá verse así:

Ahora crearemos el script para el botón de guardar:

Script

sNombre = Input.GetText("inp_nombre") sContrasena = Input.GetText("inp_contrasena") if bNewRecord then SQLite.Query(db,"insert into Usuario values(NULL, '"..sNombre.."', '"..sContrasena.."')"); nLastError = Application.GetLastError(); if nLastError ~= SQLite.OK then Dialog.Message("Error:" ..nLastError, SQLite.GetLastErrorString());

end

else SQLite.Query(db,"insert or replace into Usuario values('"..nRecordID.."', '"..sUsuario.."', '"..sContrasena.."')"); nLastError = Application.GetLastError();




if nLastError ~= SQLite.OK then Dialog.Message("Error:" ..nLastError, SQLite.GetLastErrorString());

end end

Page.Jump("Page1")

Este script es muy fácil de comprender pero de igual manera lo explicare. La primera parte declaramos los objetos junto a su campo de la tabla correspondiente, luego creamos una condición, que lo primero que si el Campo RecordID es Nulo abrirá un nuevo registro eso es para guardar por primera vez un campo, luego bien una condición de error, luego viene una opción que si el campo RecordID es igual a un número entonces Ingresara o Remplazara un campo ya existente por los nuevos datos ingresados, y luego la condición de error, al final de todo viene un salto de hoja lo que hace esto es refrescar la pantalla del programa y listo. Deberá verse al final el script de la siguiente manera.

Ahora el botón de Nuevo solo consta de dos líneas.

bNewRecord = true Page.Jump(―Page1‖)




La primera línea es el comando para agregar un Nuevo campo a la base de

datos el Segundo es un salto de hoja para activar la acción.

Ahora agreguemos la línea 1 al final del script dela tabal el que escribimos

en actions.

El botón de cancelar solamente tendrá un salto de hoja así como esta en el

botón de Nuevo:

Page.Jump(―Page1‖) Bueno de esa manera se crean los programas con bases de datos en SQLite, este es solo un ejemplo muy básico del manejo de bases de datos a de más solo es un formulario de ingreso, podemos realizar todo tipo de formularios por ejemplo: Formularios de Ingreso, Consulta, Edición de datos, Impresión de datos, Consultas, etc.

Ejercicio

Desarrolle un programa el cual Guarde la siguiente Información:

CAMPO TIPO DE CAMPO ANCHO

CODIGO NUMERICO 4

NOMBRE TEXTO 50

DEPARTAMENTO TEXTO 25

CARGO TEXTO 25

FECHA INGRESO FECHA 8

Script

Script Base de Datos




Script Formulario




Script Botón Nuevo

Script Botón Guardar




Script Botón salir




Pues una vez terminado el primer ejercicio de formularios de ingreso

procedemos a crear nuestro segundo ejercicio en el cual agregaremos una

serie de objetos nuevos que nos ayudaran mucho a la hora de hacer

nuestros programas. En esta ocasión crearemos otro formulario de ingreso

pero será un poco diferente ya que poco a poco iremos creando formularios

más completos, de esa manera nos familiarizaremos más fácil mente con

cada una de las herramientas, comandos y de más utilidades de nuestro

ensamblador.

Antes de inicias les comentare de que podemos usar casi todos los objetos

de AMS como nosotros queramos como por ejemplo los botones que los

usaremos usamos mucho pues como ven los script de los botones se

colocan casi siempre en un mismo procedimiento el cual es On Click y pues

como nos hemos dado cuanta la mayoría de los objetos tienen ese mismo

procedimiento por lo tanto podemos usar varios tipos de objetos en

remplazo de los botones, pero eso de que nos sirve dirán pues la verdad de

mucho ya que con los botones nos limitamos un poco a la hora de darle a

nuestros programas un toque más personalizado como por ejemplo

queremos crear un botón que nos haga una búsqueda si colocamos un

botón normal solo dirá buscar, si usamos un xbutton que es un poco más

avanzado le podremos agregar una imagen y bien se miran muy bien pero

si queremos solo la imagen con algún tipo de efecto creado con script lo

podemos hacer también, es una de las grandes ventajas de AMS que no

nos podemos limitar en lo que queramos siempre y cuando lo podamos

hacer, y tengamos una muy buena imaginación y creatividad ya que eso es

lo que hace de que creemos los mejores programas.

Dándoles este pequeño consejo o truco espero poder ayudarlos a crear sus

programas de diferentes maneras y estilos.




Códigos de error

0 (SQLite.OK) - Resultado de la exitosa

30001 (SQLite.ERROR) - Error de SQL o falta de base de datos

30002 (SQLite.INTERNAL) - Un error de lógica interna en SQLite

30003 (SQLite.PERM) - Acceso denegado el permiso

30004 (SQLite.ABORT) - la rutina de devolución de llamada pidió un aborto

30005 (SQLite.BUSY) - El archivo de base de datos está bloqueado

30006 (SQLite.LOCKED) - Una tabla en la base de datos está bloqueado

30007 (SQLite.NOMEM) - Una asignación de memoria no

30008 (SQLite.READONLY) - Se ha intentado escribir una base de datos de

sólo lectura

30009 (SQLite.INTERRUPT) - Operación terminado por SQLite.Interrupt ()

30010 (SQLite.IOERR) - Una especie de disco I / O error se produjo

30011 (SQLite.CORRUPT) - La imagen de disco de base de datos es

incorrecto

30012 (SQLite.NOTFOUND) - (Sólo para uso interno) Tabla o registro no se

encuentra

30013 (SQLite.FULL) - Inserción fracasó porque la base de datos está lleno

30014 (SQLite.CANTOPEN) - No se puede abrir el archivo de base de datos

30015 (SQLite.PROTOCOL) - bloqueo de base de datos de error de

protocolo

30016 (SQLite.EMPTY) - (Sólo para uso interno) Tabla de base de datos

está vacía

30017 (SQLite.SCHEMA) - El esquema de base de datos ha cambiado

30018 (SQLite.TOOBIG) - demasiados datos para una fila de una tabla

30019 (SQLite.CONSTRAINT) - Cancelar por violación a la restricción

30020 (SQLite.MISMATCH) - falta de coincidencia de tipo de datos

30021 (SQLite.MISUSE) - Biblioteca utiliza incorrectamente

30022 (SQLite.NOLFS) - Utiliza sistema operativo no cuenta con el apoyo

en el host

30023 (SQLite.AUTH) - Autorización denegada

30024 (SQLite.FORMAT) - Base de datos auxiliares error de formato

30100 (SQLite.ROW) - SQLite.Step () tiene otra fila listo

30101 (SQLite.DONE) - SQLite.Step() has finished executing

30200 (SQLite.UNCOMPILED) - Listado de cambios




Ejercicio

Desarrolle un programa el cual Guarde la siguiente Información:


PLACA ALFANUMERICO 8

MARCA TEXTO 20

MODELO TEXTO 25

COLOR TEXTO 15

AÑO FECHA 4

El programa deberá verse de la siguiente manera:

En este programa como podemos ver tenemos un tipo de objeto diferente el

cual es un ComboBox y este objeto nos da las facilidades de poder crear

listas desplegables con una serie de opciones las cuales tienen por nombre

Ítem podemos agregar todas las Ítem que queramos y elegir cuantas se

visualicen al desplegar la lista y a partir de ella iniciara la barra de

desplazamiento, sin embargo también podemos usar estos objetos como




Input ya que tienen la opción de cambiar de modificar selección simple a

modo selección editable como pueden ver en la captura el campo Marca es

un ComboBox normal y el campo Modelo es un ComboBox editable en el

cual si las opciones que están listadas no son las que ocupamos podemos

agregar la nuestra sin ningún tipo de problema lo único es que no quedara

almacenada en la lista del ComboBox pero si se guardara en el registro.

Ahora procederé a desarrollar el programa casi paso a paso ya que no

explicare varias cosas porque ya han sido explicadas anterior mente.

Para agregar un ComboBox y agregar los Ítem dentro es de la siguiente

manera primero que nada lo agregamos dando un Click en el botón de

ComboBox de la barra de botones estándar luego de eso le daremos Click

derecho para entrar a las propiedades del ComboBox y veremos la

siguiente ventana:




Como pueden ver tiene una gran cantidad de opciones las cuales les

explicare a continuación:

Este panel es en cual nosotros colocamos las Ítem que queremos que tenga

el combobox pero las colocamos en la columna Ítem Text, la columna Ítem

Data nos sirve para relacionar un ítem con alguna hoja de nuestro

formulario o con algún objeto exterior claro que siempre debemos de

colocarle el script correspondiente para que funcione correctamente.

El botón inferior que dice Insert Row es insertar Fila como por ejemplo

tenemos los tres primeros Ítem pero entre el uno y el dos queremos colocar

un en vez de borrar los inferiores nos colocamos en el Ítem superior al que

queremos agregar y presionamos ese botón y listo.

El siguiente botón borra una fila, la fila que borrara es la seleccionada los

otros mueven un Ítem asía arriba y el otro un Ítem asía abajo.




Los otros Desplazan un Ítem al inicio y el otro al final.

Con estas opciones podemos cambiar de un ComboBox normal a un

ComboBox Editable simplemente seleccionando una de las dos opciones

que nos presenta si seleccionamos la primera opción nuestro ComboBox

será normal se vera de la siguiente manera:

Y si seleccionamos la opción número dos será un ComboBox con opción a

modificar los Ítem agregados y se vera de la siguiente manera:

Y de esa manera podemos crear dos tipos de ComboBox que nos facilitaran

de muchas maneras la programación.

Este panel nos da la opción de decidir cuantas ítem queremos que se

muestren al desplegar el menú per defecto trae 4 pero nosotros podemos

colocar el número que mejor nos convenga, aparte de ello podemos

cambiar el tipo de letra que queramos que tenga.

Este panel nos da las siguientes opciones la de poder cambiar el color de

fondo de nuestros ComboBox.






La segunda opción la de poder cambiar el color de fuente de nuestros

ComboBox.

La tercera opción nos da la posibilidad de alinear el texto.

De esta manera concluye la explicación de las propiedades de configuración

de los ComboBox, Ahora procederé a desarrollar el script correspondiente

para nuestro formulario.

Script

Este es el script de la creación de la Base de datos y la tabla que estarán

ubicados en el siguiente prodecimiento: Project-Action

sDatabaseFile = _SourceFolder.. "\\Autoplay\\Docs\\Autos.db";





end

SQLite.Query(db, "CREATE Table Ingreso_Autos(RecordID integer primery key, usuario text, contrasena text)");

bNewRecord = true

Ahora el script del formulario en el procedimiento On Preload

if bNewRecord then --establecer el texto de entrada para limpiar los objetos

Input.SetText("inp_placa", ""); ComboBox.SetText("cbx_color", ""); ComboBox.SetText("cbx_marca", ""); ComboBox.SetText("cbx_modelo", ""); ComboBox.SetText("cmx_ano", "");




else tIngreso_Autos = SQLite.QueryToTable(db, "Select * from Ingreso_Autos where RecordID="..nRecordID) --Relacionar variables con los campos de la tabla

nRecordID = tIngreso_Autos.Data[1]["RecordID"]; sPlaca = tIngreso_Autos.Data[1]["Placa"]; sColor = tIngreso_Autos.Data[1]["Color"]; sMarca = tIngreso_Autos.Data[1]["Marca"]; sModelo = tIngreso_Autos.Data[1]["Modelo"]; sAno = tIngreso_Autos.Data[1]["Ano"]; --establecer el texto de entrada si se ha escrito en ellos Input.SetText("inp_placa", sPlaca); ComboBox.SetText("cbx_color", sColor); ComboBox.SetText("cbx_marca", sMarca); ComboBox.SetText("cbx_modelo", sModelo); ComboBox.SetText("cmx_ano", sAno); end Este es el script para el botón de Guardar el cual estará colocado en procedimiento On Click --relacionar variables con los objetos del formulario sPlaca = Input.GetText("Input_Nombre"); sMarca = ComboBox.GetText("cbx_marca"); sModelo = ComboBox.GetText("cbx_modelo") sColor = ComboBox.GetText("cbx_color") sAno = ComboBox.GetText("cmx_ano") --Si es primera vez que agregamos este registro realizara esta acción

if bNewRecord then SQLite.Query(db,"insert into Ingreso_Autos values(NULL, '"..sPlaca.."', '"..sMarca.."', '"..sModelo.."', '"..sColor.."', '"..sAno.."')"); nLastError = Application.GetLastError();




if nLastError ~= SQLite.OK then Dialog.Message("Error: " .. nLastError, SQLite.GetLastErrorString()); end else -- si no -- Realizara esta otra la cual es insertar nuevo registro o modificar registro existente

SQLite.Query(db,"insert or replace into Ingreso_Autos values('".. nRecordID .."', '"..sPlaca.."', '"..sMarca.."', '"..sModelo.."', '"..sColor.."', '"..sAno.."')"); nLastError = Application.GetLastError(); if nLastError ~= SQLite.OK then Dialog.Message("Error: " .. nLastError, SQLite.GetLastErrorString()); end end -- Luego de haber hecho cualquiera de las 4 condiciones hará un salto de hoja a la misma hoja

Page.Jump("Page1") Ahora este es el script para el botón Nuevo el cual estará colocado en el procedimiento On Click --Abrir un registro en blanco en la tabla

bNewRecord = true --hacer un salto de hoja para poner en funcionamiento el comando

Page.Jump("Page1") Ahora el script para el botón de Salir será colocando de igual manera en el procedimiento On Click --Este script lo que hace es cerrar nuestro programa

Application.Exit(0);




De esta manera ya tenemos creado nuestro programa sin ninguna dificultad y podremos proceder a agregar los registros correspondientes, pero se preguntaran como hago para saber si mi programa está realmente guardando lo que estoy ingresando pues es muy fácil hacerlo lo que aremos será un método de listado de registros para que con forme vallamos agregando registros nos los muestre en la lista. Para ello agregaremos un objeto de lista a nuestro formulario el cual lo colocaremos en la parte inferior de nuestro formulario, nuestro formulario de vera verse de la siguiente manera con la lista agregada.

Cuando esté lista le colocaremos un nombre interno el cual será:

lst_Listado, y comenzaremos a crear el script correspondiente para que

funcione correctamente e interactúe con nuestra base de datos.

Para ello ingresamos a las propiedades de nuestra hoja o formulario y

colocaremos nuestro script en el procedimiento On Preload, lo colocaremos

debajo del script que ya teníamos agregado para el formulario de ingreso en

una línea inferior para no crear conflictos en el script.




El script para hacer la comprobación de ingreso de registros a nuestra base

de datos es el siguiente:

Script

-- Borrar el contenido de todos los elementos del ListBox

ListBox.DeleteItem("lst_Listado", -1); -- tabla de consulta y almacenar todas las entradas en la tabla Ingreso_Autos

tIngreso_Autos = SQLite.QueryToTable(db,"SELECT * FROM Ingreso_Autos"); nLastError = Application.GetLastError(); if nLastError ~= SQLite.OK then Dialog.Message("Error", SQLite.GetLastErrorString()); end -- si no hay errores, continuar, de lo contrario no hacer nada

if nLastError == SQLite.OK then --recorrer la tabla for nRow = 1,tIngreso_Autos.Rows do --obtener el título del registro actual sItem = tIngreso_Autos.Data[nRow]["Marca"]; --añadir el elemento a la lista con el texto y los datos de Campo == Marca --Usar el RecordID en los números de columna, para los campos mostrados

ListBox.AddItem("lst_Listado", tIngreso_Autos.Data[nRow]["Marca"], tIngreso_Autos.Data[nRow]["RecordID"]); end end




Con este script lo que lograremos será que cuando tengamos en ejecución

nuestro programa podremos ver en el ListBox todos los registros ingresados

en el orden en el cual fueron ingresados, dando como resultado una

comprobación efectiva de que nuestros programas guardan correctamente

la información.

El campo que utilice en este ejemplo es la marca del auto pero nosotros

podemos colocar cualquier campo solo bastaría en cambiar el campo parca

por el que nosotros queramos por ejemplo si queremos que la

comprobación nos mostrara el resultado por color las líneas que tendríamos

que cambiar se mirarían de la siguiente manera:

sItem = tIngreso_Autos.Data[nRow]["Color"];

ListBox.AddItem("lst_Listado", tIngreso_Autos.Data[nRow]["Color"], tIngreso_Autos.Data[nRow]["RecordID"]);

Listo con esto ya tendríamos una comprobación por el campo Color, como

pueden ver es muy fácil de realizar.

Resultado Final:




Ejercicio

Desarrolle un programa el cual Guarde la siguiente Información y tenga una

lista de verificación de datos:

El programa tratara de Matricula de alumnos de un instituto, el cual impartirá

las siguientes áreas de estudio: Ciclo Común, Bachillerato Técnico en

Computación, Educación Comercial, Administración de Empresas,

Bachillerato por Madurez.


Numero_Libreta NUMERO 6

Numero_Registro TEXTO 15

Nombre_Alum TEXTO 40

Apellido_Alum TEXTO 40

Edad NUMERO 2

Fec_Naci FECHA 8

Telefono NUMERO 8

Celular NUMERO 9

Direccion TEXTO 50

Encargado TEXTO 50

Curso TEXTO 7

Seccion TEXTO 2

Modalidad TEXTO 20

Jornada TEXTO 10

Pagos TEXTO 2

Mensualidades TEXTO 11

Esa es la tabla que deberán de desarrollar, como podemos ver el ancho de

los campos esta vez es más variante que en los ejercicios anteriores, por

ello pondremos en práctica lo del uso de las máscaras personalizadas que

aprendimos unos capítulos atrás para poder darle este estilo más

profesional.




El formulario deberá verse de la siguiente manera:

Cuando lo tengan de esta manera procederán a desarrollar el script

correspondiente.




Script


Script Formulario




Script Lista de Verificación




Script Botón Nuevo


Script Botón Salir




Formularios de Ingreso y Consulta

En este capítulo veremos cómo crear formularios de ingreso enlazados a

uno o varios formularios de consulta de datos.

En esta ocasión tomaremos como base un programa que almacenara datos

telefónicos de diferentes compañías, en esta ocasión cambiaremos los

botones por etiquetas agrupadas a imágenes, las cuales crearan el entorno

de un botón, dándole al programa un toque más gráfico y atractivo, el

programa tendrá una serie de novedades que con ellas lograras aprender

diversas técnicas a la hora de crear tus sistemas.

Captura del Menú:




Captura del formulario de Ingreso:




Formulario de consulta:

Como podemos ver en las capturas los formularios tienen una apariencia

total mente diferente a los que hemos estado creando anterior mente pero

eso no hace que a la hora de programas sea más difícil la programación es

prácticamente la misma solo que agregamos unas pocas líneas más de

códigos pero es para darle efectos a nuestro programa no es nada

complicado lo primero que debemos de hacer es crear la estructura del

programa como pueden apreciar en las imágenes crearemos tres

formularios los cuales serán: Menú, Ingreso, Consulta.




En las imágenes podemos apreciar otras opciones pero en este ejemplo no

las crearemos solo crearemos los formularios que se mencionan para no

confundirnos.

Una vez que tenemos creado los formularios y le hemos colocado los

nombres correctos a cada uno de los objetos, procederemos a crear la base

de datos y activar el plugins de SQLite.

Script Base de datos

sDatabaseFile = _SourceFolder.. "\\Autoplay\\Docs\\Telefonos.db";


nLastError = Application.GetLastError();


Dialog.Message("Error abriendo la base de datos", SQLite.GetLastErrorString());

end

SQLite.Query(db, "CREATE Table Telefonos2010(RecordID integer primery key,

Nombre text, Apellido text, Compania text, Ciudades text, Telefono text, Direccion

text)")

bNewRecord = true;

Este es el script para la base de datos y su tabla como podemos ver la

base de datos tiene por nombre Teléfonos, y la tabla Telefonos2010, no

olvidemos como le colocamos por nombre a la base de datos y a la tabla ya

que ocuparemos esos nombres más adelante.

Ahora crearemos el script para el formulario de menú el cual lo colocaremos

en el procedimiento On Show, para que cuando se ejecute el programa al

cargar nos ejecute el script correspondiente.




Script Formulario Menú

ListBox.DeleteItem("Lista", -1); tTelefonos2010 = SQLite.QueryToTable(db,"SELECT * FROM Telefonos2010"); nLastError = Application.GetLastError(); if nLastError ~= SQLite.OK then Dialog.Message("Error", SQLite.GetLastErrorString()); end -- si no hubo errores, continúe, de lo contrario no hace nada. if nLastError == SQLite.OK then --recorrer la tabla for nRow = 1,tTelefonos2010.Rows do --obtener el título del registro actual sNombre = tTelefonos2010.Data[nRow]["Nombre"]; sApellido = tTelefonos2010.Data[nRow]["Apellido"]; --Agregar el elemento a el Listbox = nombre y Apellido = número de columna (en la tabla)

ListBox.AddItem("Lista", sNombre.. " ".. sApellido, nRow); end end

Este es el script que ara que la ListBox que tenemos agregado al menú nos muestre la información guardada en la tabla mostrándonos los campos de la siguiente manera: Nombre y Apellido Juntos por ejemplo: Douglas A. Rivera Castillo, como recordamos en las clases anteriores les explique para que servían los dos puntos seguidos forman una cadena o encadenamiento y lo que encadenamos son los dos campos que queremos que nos muestre, podemos agregar todos los campos que queramos. Ahora nos faltan los script de los botones.

Script Botón Agregar bNewRecord = true; Page.Jump("Agregar2")

Script Botón Consulta Page.Jump("Consultas")




De esta manera terminamos de crear nuestro formulario de menú y ahora procedemos a crear el formulario de ingreso de datos para ello ya debemos de haber terminado el diseño de dicho formulario para proceder directamente a crear nuestro script.

Script Formulario Ingreso Procedimiento: On Preload if bNewRecord then Input.SetText("Input_Nombre", ""); Input.SetText("Input_Apellido", ""); Input.SetText("Input_Direccion", ""); Input.SetText("Input_Telefono", ""); ComboBox.SetText("cbn_Companias", ""); ComboBox.SetText("cbn_ciudad", ""); Label.SetVisible("Estado", false); end

Este script lo que hace es limpiar todos los objetos de nuestro formulario de ingreso para que cuando cargue, este total mente limpias las cajas de texto y ComboBox. Ahora como ya tenemos listo esto procederemos a desarrollar el script para el botón de guardar este botón no cambiara mucho de los botones que hemos creado anterior mente ya que ara prácticamente lo mismo guardar un nuevo registro o remplazar uno ya existente pero le hemos agregado una nueva opción que es que cuando guarde si es que guarda nos muestre una etiqueta que nos diga que nuestro registro ha sido guardado correctamente. Esta opción no es nada complicada de hacer lo que hicimos fue crear la etiqueta y le colocamos el mensaje le colocamos un nombre a la etiqueta y luego le desactivamos la opción de visibilidad y en el script lo que hicimos fue de que si cumple una condición la muestre y si no la cumple que no la muestre.




Script Botón Guardar Procedimiento: On Click sNombre = Input.GetText("Input_Nombre"); sApellido = Input.GetText("Input_Apellido"); sCompania = ComboBox.GetText("cbn_Companias"); sCiudades = ComboBox.GetText("cbn_ciudad"); sTelefono = Input.GetText("Input_Telefono"); sDireccion = Input.GetText("Input_Direccion"); if bNewRecord then SQLite.Query(db, "insert into Telefonos2010 values(NULL, '"..sNombre.."', '"..sApellido.."', '"..sCompania.."', '"..sCiudades.."', '"..sTelefono.."', '"..sDireccion.."')"); nLastError = Application.GetLastError(); if nLastError ~= SQLite.OK then Dialog.Message("Error:".. nLastError, SQLite.GetLastErrorString()); end else SQLite.Query(db, "insert or replace into Telefonos2010 values('" .. nRecordID .. "', '"..sNombre.."', '"..sApellido.."', '"..sCompania.."', '"..sCiudades.."', '"..sTelefono.."', '"..sDireccion.."')"); nLastError = Application.GetLastError(); if nLastError ~= SQLite.OK then Dialog.Message("Error:".. nLastError, SQLite.GetLastErrorString()); end end Label.SetVisible("Estado", true);

Bueno eso es todo el script de botón de guardar se se fijan lo único nuevo es la última fila y es la que hace que muestre la etiqueta si se guardó el registro, los otros botones del formulario ya sabemos cómo hacerlos a sí que no colocare el script para ellos. Ahora pasaremos al formulario de consulta que es prácticamente igual que el de ingreso con la única diferencia de que tendrá un ListBox.




Script Formulario Consulta Procedimiento: On Show ---Limpiar todas las Input y Combobox al cargar

Input.SetText("nomb re", ""); Input.SetText("Apellido_inp", ""); Input.SetText("direccion", ""); Input.SetText("telefono", ""); Input.SetText("compañia", ""); Input.SetText("ciudades", ""); ComboBox.SetText("cbn_Companias", ""); ComboBox.SetText("cbn_ciudad", ""); -- Borrar el contenido de todos los elementos de la página...

ListBox.DeleteItem("Lista", -1); tTelefonos = SQLite.QueryToTable(db,"SELECT * FROM Telefonos2010"); nLastError = Application.GetLastError(); if nLastError ~= SQLite.OK then Dialog.Message("Error", SQLite.GetLastErrorString()); end -- si no hubo errores, continúe, de lo contrario no hace nada. if nLastError == SQLite.OK then --recorrer la tabla

for nRow = 1,tTelefonos.Rows do --obtener el título del registro actual sNombre = tTelefonos2010.Data[nRow]["Nombre"]; sApellido = tTelefonos2010.Data[nRow]["Apellido"]; sCompania = tTelefonos2010.Data[nRow]["Compania"]; sTelefono = tTelefonos2010.Data[nRow]["Telefono"]; ListBox.AddItem("Lista", "Nombre Completo".. ": ".. sNombre.." "..sApellido.. " ".. " Compañia Telefonica: "..sCompania.. " ".. "Numero Telefonico: ".. sTelefono, nRow); end end --contar los ítem del Listbox para verificar cuantos registros hay ingresados

Total = ListBox.GetCount("Lista"); Label.SetText("ID", Total);




Este script es prácticamente lo mismo que el de menú lo único que hemos encadenado más campos a la lista y aparte de ello creamos un contador de Ítem del ListBox para que de esa manera tengamos un conteo continuo de los registros guardados en la tabla. Ahora crearemos el script del ListBox para que cuando seleccionemos algún Ítem nos muestre la información guardada en ese registro en los campos correspondientes de nuestro formulario.

Script Formulario Consulta, ListBox Procedimiento: On Select --obtener elemento seleccionado y almacenar en una tabla

tSelected = ListBox.GetSelected("Lista"); if tSelected then

--obtener el número de fila de tabla (Almacenados en Telefonos2010 de la ListBox nItemRowNumber = String.ToNumber(ListBox.GetItemData("Lista", tSelected[1]));

--Obtener el Nombre , Apellido, Compania, Ciudad, Telefono, Direccion de la base de datos

nRecordID = tTelefonos2010.Data[nItemRowNumber]["RecordID"]; sNombre = tTelefonos2010.Data[nItemRowNumber]["Nombre"]; sApellido = tTelefonos2010.Data[nItemRowNumber]["Apellido"]; sCompania = tTelefonos2010.Data[nItemRowNumber]["Compania"]; sCiudades = tTelefonos2010.Data[nItemRowNumber]["Ciudades"]; sTelefono = tTelefonos2010.Data[nItemRowNumber]["Telefono"]; sDireccion = tTelefonos2010.Data[nItemRowNumber]["Direccion"];

--Pegara las entradas almacenadas en la base de datos en las Input Correspondientes

Input.SetText("nomb re", sNombre) Input.SetText("Apellido_inp", sApellido) Input.SetText("compañia", sCompania) Input.SetText("ciudades", sCiudades) Input.SetText("telefono", sTelefono) Input.SetText("direccion", sDireccion) end

Este script es fácil de comprender como podemos leer en los comentarios agregados en el script podemos darnos cuenta de que es lo que hace cada fila del script. La primera fila del script lo que hace es que obtiene los datos seleccionados y almacenados en la tabla en este caso Telefonos2010 luego




creamos una condición de los datos seleccionados, que obtendrá una entrada en el ListBox, Luego cargara los campos de la tabla Telefonos2010 que se colocan en la filas con las variables de cada uno de los campos y lo último pegara la información del campo seleccionado. De esta mera ya hemos creado un formulario de consulta de datos en nuestro sistema, los de más botones ya podemos hacerlos fácil mente así que no los explicare. Ejercicio Desarrolle un programa el cual Guarde la siguiente Información:

CAMPO TIPO DE CAMPO ANCHO CODIGO NUMERICO 6 TITULO TEXTO 40 DIRECTOR TEXTO 40 CALIFICACION TEXTO 15 NACIONALIDAD TEXTO 25 PAISES TEXTO 20 INTERPRETES TEXTO 50 FORMATO TEXTO 10 DURACION NUMERICO 6 PELICULA TEXTO 30 GENERO TEXTO 25 SINOPSIS TEXTO 60 FECHA FECHA 8 EXISTENCIA NUMERICO 4 PRECIO MONEDA 4.2

Este programa será para gestión de una sala de renta de películas el cual

tendrá formulario de menú, ingreso y consulta, deberá verse de la siguiente

manera:




Formulario de Ingreso

Formulario de Menú




La captura del formulario de consulta no la coloco ya que la dejare a su

imaginación para verificar que tan analistas son, espero que me sorprendan.

Script


Script Formulario de Menú

Script Botón Agregar

Script Botón Consultar




Script Botón Salir

Script Formulario de Ingreso

Script Formulario

Procedimiento: On Preload





Procedimiento: On Click




Script Botón Cancelar


Script Formulario de Consulta

Script Formulario

Procedimiento: On Show




Script Formulario Consulta, ListBox Procedimiento: On Select




Ejercicio Desarrolle un programa el cual Guarde la siguiente Información:


LIBRETA NUMERICO 6

REGISTRO NUMERICO 15

NOMBRE TEXTO 40

APELLIDO TEXTO 40

EDAD NUMERICO 2

FECHA FECHA 8

TELEFONO NUMERO 12

DIRECCION MEMO

CURSO NUMERICO 1

SECCION TEXTO 2

MODALIDAD TEXTO 25

JORNADA TEXTO 15

PAGO MONEDA 4.2

MENSUALIDAD TEXTO 2

Este programa será para gestión de matrículas estudiantiles el cual tendrá

formulario de menú, ingreso y consulta, deberá verse de la siguiente

manera:





Formulario de Menú



Script








Script Botón Salir





Script Formulario





Como podemos ver hemos logrado comprender muy bien el desarrollo de

los formularios de consultas, no solo existe este método de desarrollo de

consultas hay una gran variedad de métodos pero para mí esta es la mejor

manera en la que podemos realizar consultas rápidamente y de una manera

muy ordenada, ahora entre algunas cosas que les faltan a nuestros

sistemas es la búsqueda de campos dentro de una tabla pero para ello solo

ocupamos crear unas cuantas filas de script eso es muy fácil de hacer lo

único que tendremos que hacer es agregar a nuestro formulario de consulta

una Input y un botón más los cuales nos serán de referencia para las

búsquedas a continuación les explicare como realizar este función tan útil a

la hora de trabajar con nuestras consultas.

Tomaremos como ejemplo el último programa que creamos el de matrículas

estudiantiles:

Script Botón Buscar

---Desactive todas las casillas Input.SetText("informacion_info", ""); Input.SetText("Total input", ""); ListBox.DeleteItem("nombre_List", -1); ---obtener una entrada de búsqueda

sSearch = Input.GetText("Search"); if sSearch ~= "" then -- Matriculas tabla de consulta y almacenar todas las entradas en la tabla tblRS = SQLite.QueryToTable(db, "Select * from Matriculas where (Libreta LIKE '%"..Input.GetText("Search").."%') or (Registro LIKE '%"..Input.GetText("Search").."%') or (Nombre LIKE '%"..Input.GetText("Search").."%')")

nLastError = Application.GetLastError(); if nLastError ~= SQLite.OK then Dialog.Message("Error", SQLite.GetLastErrorString()); end




-- si no hay errores, continuar, de lo contrario no hacer nada

if nLastError == SQLite.OK then --recorrer la tabla

for nRow = 1,tblRS.Rows do --obtener el título del registro actual sTitle = tblRS.Data[nRow]["Libreta"]; --añadir el elemento a la lista con el texto = ---Mostrar diálogo de estado para el progreso de actualización ncount = Table.Count(tInfo_List); StatusDlg.Show(MB_ICONNONE, false); StatusDlg.SetMeterRange(1, 50); StatusDlg.SetMeterPos(1); StatusDlg.SetTitle("Refrescar la Busqueda por Nombre"); StatusDlg.SetMeterRange(1, nCount); --y el RecordID ListBox.AddItem("nombre_List", tblRS.Data[nRow]["Libreta"], tblRS.Data[nRow]["RecordID"]);

end end StatusDlg.Hide(); else end ---pantalla de resultados de búsqueda total de registros

Total = ListBox.GetCount("nombre_List"); Input.SetText("Total input", Total); ---Limpiar Input buscar

Input.SetText("Search", "");

Este es el script del botón buscar cómo podemos ver es un poco grande pero los resultados obtenidos gracias a este script son sorprendentes ya que logramos hacer búsquedas por los campos que ocupemos sin tener limitaciones a la hora de las búsquedas claro que hay muchos más métodos de búsquedas pero este es el más eficiente y rápido. Ahora que ya sabemos cómo hacer la opción de búsquedas en nuestros formularios solo queda explicar cómo hacer un buscador incremental el cual nos sirve para buscar de una mara más rápida y precisa la información




almacenada en una lista para ello crearemos un programa de búsqueda muy sencillo: Ejercicio

BUSCARDOR INCREMENTAL

En este ejercicio desarrollaremos un buscador incremental el cual realizara

búsquedas en una lista de información conforme nosotros vallamos

escribiendo dándonos un resultado exacto de nuestra búsqueda, lo que

usaremos para el desarrollo de este programa será únicamente una Input y

Un ListBox los cuales formaran todo nuestro programa les adjunto una

captura de cómo deberán de colocar los objetos en su programa para

proceder al desarrollo de dicho programa.

Como pueden ver en la captura ya está ordenado y agregados los datos en

nuestros objetos lo de agregar los datos en el ListBox será desarrollado en

el aula de clases. Ahora procedemos al desarrollo de nuestra programación

para poder hacer funcionar nuestro programa, toda la programación será

escrita en el Input.

Entramos a las propiedades de nuestra Input y nos dirigimos a la pestaña

llamada Script en ella nos posicionaremos en el evento ON KEY, ahí es

donde escribiremos toda la script que hará que nuestro programa funcione

correctamente, procedemos al desarrollo:





Script

if Input.GetText("Input1") ~= "" then

V = Input.GetText("Input1");

for i = 1 , ListBox.GetCount("ListBox1") do

M = ListBox.GetItemText("ListBox1",i);

k = String.Length(V);

if String.Upper(String.Left(V,k)) == String.Upper(String.Left(M,k)) then

ListBox.SelectItem("ListBox1",i);

end;

end;

end;

Como podemos ver este buscador es total mente diferente que el anterior

ya que este no realiza búsquedas dentro de una base de datos si no que lo

hace solamente dentro de un objeto en este caso es un ListBox aunque lo

podemos combinar con el otro buscador para poder realizar una búsqueda

aún más avanzada.

Ahora realizaremos un Ejercicio de cálculos matemáticos para ir

comenzando a realizar programas un poco más complejos.




Ejercicio CALCULOS BASICOS MATEMATICOS

En este ejercicio lo que haremos pues será realizar operaciones

matemáticas básicas las cuales son sumas, restas, multiplicaciones y

divisiones aplicando la lógica del script de LUA a simple vista se mira algo

muy fácil de lograr hacer pero no es a si ya que debemos de comprender

las lógicas matemáticas para poder lograr hacer funcionar esto en AMS si

tenemos más o menos una lógica sobre esto se nos hará muy fácil realizar y

comprender este programa.

Lo que ocuparemos agregar a nuestro programa serán unos cuantos

objetos o elementos para poder hacerlo funcionar, procedo a explicar que

es lo que ocuparemos: dos (2) Input, tres (3) Etiquetas, un (1) Paragraph y

por últimos un (1) Botón. Teniendo ya todos estos elementos agregados en

nuestro programa deberemos proceder a ordenarlos de la manera que se

muestra en la imagen:

Cuando ya hayamos terminado de ordenar nuestro programa procederemos

al desarrollo de la script que realizara los cálculos de las Input y nos

mostrara los resultados en el Paragraph, este ejemplo solo mostrara como

realizar un tipo de cálculo lo cual no quiere decir que solo ese se puede

realizar trabajaremos con algo fácil una suma.




Bueno ahora ya que tenemos todo listo procederemos a darle el script a

nuestro Botón Calcular,

Entramos a las propiedades de nuestro botón y nos dirigimos a la pestaña

llamada Script en ella nos posicionaremos en el evento ON CLICK, ahí es

donde escribiremos toda la script que hará que nuestro programa funcione

correctamente, procedemos al desarrollo:

--Esta parte Leerá los valores en las Input. --para que Usar la String.ToNumber para asegurar el resultado numérico.

nNumber1 = String.ToNumber(Input.GetText("Input1")); nNumber2 = String.ToNumber(Input.GetText("Input2")); -- esta parte definirá el resultado en el paragraph

Paragraph.SetText("Paragraph1","El Resultado de:".. nNumber1 .. " + " .. nNumber2 .. " = " ..nNumber1 + nNumber2)

Ese es todo el Script necesario para poder desarrollar el programa ahora

procederé a explicar más detallada mente toda la Script:

nNumber1 y nNumber2: Son las Variables que le damos las Input 1 y 2

String.ToNumber: esta parte lo que hace es que las Input solo soporten

números para ser calculados

Input.GetText: esto es lo que leerá el contenido de las Input

Paragraph.SetText: esta parte representará el texto colocado en las Input

de una manera ordenada

"Paragraph1",: esta parte lo que hace es que indica en que paragraph se

mostrara el resultado

"El Resultado de:".. nNumber1 .. " + " .. nNumber2 .. " = ": esta parte es

una breve reseña que se mostrara al ejecutar el script en el paragraph1

claro que no mostrara los nombres de variables solo mostrara el contenido

en ellas representándolo de la siguiente manera El Resultado de: 10+10=20

..nNumber1 + nNumber2: esta parte es la que realizara toda la operación

matemática como ven muestra los nombres de las dos variables de las Input




1 y 2 las cuales están separadas por un signo matemático que representa a

las Sumas.

Si nosotros quisiéramos que nuestro programa realizara multiplicaciones,

divisiones o cualquier otra operación solo deberíamos de cambiar el signo

más (+) por el de la operación que quisiéramos hacer y listo ya tendríamos

nuestra calculadora básica.

Y una vez terminada nuestra Script debería verse así:

Una vez explicado todo el Script solo queda que realices este ejemplo y pongas en práctica lo aprendido.




Ejercicio PROGRAMA FACTURACION

En este ejercicio desarrollaremos un programa de facturación básico

aplicando lo aprendido en los ejercicios anteriores, lo objetos que usaremos

para desarrollar nuestro programa serán los básicos las Input, Etiquetas y

Botones de comando.

Bueno les dejo una captura de cómo se deberá ordenar el programa para su

posterior programación:

Una vez tengamos ordenado nuestro programa de esa forma procedemos a

el desarrollo de su programación para que realice todas sus operaciones

correctamente, lo que aremos será dirigirnos a las propiedades del botón

Calcular y dar un click en la pestaña Script en ella nos posicionaremos en la

pestaña On Click para comenzar con el desarrollo de nuestro programa lo

primero que aremos será verificar los nombres de nuestro objetos ya que

los ocuparemos para declararlos en nuestro programa, bueno ya teniendo

esto listo comenzamos a trabajar en la programación.





Script

Botón Calcular:


-- fila 01

cantidad_1 = Input.GetText("Input6");


resultado = cantidad_1 * cantidad_2

Input.SetText("Input14", resultado);

Esta parte que tenemos aquí es la que realizara los cálculos de la primera

fila de la factura.

--Sub total

result_A = Input.GetText("Input14");

result_B = Input.GetText("Input15");

result_C = Input.GetText("Input16");

result_D = Input.GetText("Input17");

resultado = result_A + result_B + result_C + result_D


-- Impuesto

Consulta_A = Input.GetText("Input18");

resultado = Consulta_A * 0.12





-- Total a Pagar



resultado = cantidad_20 + cantidad_21


Script Botón Limpiar


if Cantidad_1 ~= "" then

Input.SetText("Input1", "");

end

Bueno ya teniendo esto tendremos listo nuestro programa de facturación

como podemos ver el script es un poco complicado pero nada difícil de

comprender, una vez comprendido esto nos será mucho más fácil manejar

los formularios que realicen cálculos matemáticos.





CAMPO TIPO DE CAMPO ANCHO CODIGO NUMERICO 6

ALUMNO TEXTO 50

MODALIDAD TEXTO 20

JORNADA TEXTO 15

CURSO NUMERO 2

SECCION TEXTO 2

ASIGNATURA1 TEXTO 25






ACUMULATIVO1 NUMERICO 2






EXAMEN1_1 NUMERICO 2












TOTAL1 NUMERICO 2

TOTAL2 NUMERICO 2

TOTAL3 NUMERICO 2

TOTAL4 NUMERICO 2

TOTAL5 NUMERICO 2

TOTAL6 NUMERICO 2

PROMEDIO DEL 1 AL 6

NUMERICO 2




Este programa será para gestión de sistema de calificaciones de alumnos

de un instituto educativo el cual tendrá formulario de menú, ingreso,

consulta.

Deberá verse de la siguiente manera:

Formulario de Menú

Es este formulario se agregan una serie de script nuevos que son para que

cuando coloquemos el puntero sobre cada uno de los botones nos muestren

una etiqueta en la parte inferior diciendo que tipo de formulario cargara al

presionarlo y aparte de ello nos carga en el centro de nuestro formulario una

imagen representativa del formulario, esto será explicado en clase, pero de

igual manera es muy parecido a el formulario de ingreso de Telefonos2010

que cuando se guardaba correcta mente mostraba una etiqueta.





En este formulario como podemos ver lo tenemos todo con Input pero

nosotros cambiaremos las Input de Modalidad, Jornada, Curso, Sección por

ListBox ya que en ellas agregaremos los datos por defecto de nuestro

sistema.






Script








Script Botón Salir


Script Formulario





Script Botón Calcular


------------------------------*********PROGRAMACION*********------------------------------ acumulativo = Input.GetText("Input_Acum1")-- Variable para lectura de Acumulado ExamN_1 = Input.GetText("Input_Exam1") -- Variables par lectura de exanebn 1 ExamN_2 = Input.GetText("Input_Exam2_1") -- Variable para lectura de examen 2 operacion_Total = acumulativo + ExamN_1 + ExamN_2 -- calculo de nota total operacion_Promedio = operacion_Total / 4 -- calculo de promedio parcial imprimi_Total = Input.SetText("Input_Total1", operacion_Total) -- impriendo nota total inprimir_Promedio = Input.SetText("Input_Promedio1", operacion_Promedio) -- imprimiendo promedio parcial ------------------------------******************************------------------------------ ------------------------------******************************------------------------------




------------------------------*********LABORATORIO*********------------------------------ acumulativo = Input.GetText("Input_Acum2")-- Variable para lectura de Acumulado ExamN_1 = Input.GetText("Input_Exam2") -- Variables par lectura de exanebn 1 ExamN_2 = Input.GetText("Input_Exam2_2") -- Variable para lectura de examen 2 operacion_Total = acumulativo + ExamN_1 + ExamN_2 -- calculo de nota total operacion_Promedio = operacion_Total / 4 -- calculo de promedio parcial imprimi_Total = Input.SetText("Input_Total2", operacion_Total) -- impriendo nota total inprimir_Promedio = Input.SetText("Input_Promedio2", operacion_Promedio) -- imprimiendo promedio parcial ------------------------------******************************------------------------------ ------------------------------******************************------------------------------ ------------------------------*********INFORMATICA*********------------------------------ acumulativo = Input.GetText("Input_Acum3")-- Variable para lectura de Acumulado ExamN_1 = Input.GetText("Input_Exam3") -- Variables par lectura de exanebn 1 ExamN_2 = Input.GetText("Input_Exam2_3") -- Variable para lectura de examen 2 operacion_Total = acumulativo + ExamN_1 + ExamN_2 -- calculo de nota total operacion_Promedio = operacion_Total / 4 -- calculo de promedio parcial imprimi_Total = Input.SetText("Input_Total3", operacion_Total) -- impriendo nota total inprimir_Promedio = Input.SetText("Input_Promedio3", operacion_Promedio) -- imprimiendo promedio parcial ------------------------------******************************------------------------------ ------------------------------******************************------------------------------ ------------------------------*********ANALISIS Y DISEÑO*********------------------------------ acumulativo = Input.GetText("Input_Acum4")-- Variable para lectura de Acumulado ExamN_1 = Input.GetText("Input_Exam4") -- Variables par lectura de exanebn 1 ExamN_2 = Input.GetText("Input_Exam2_4") -- Variable para lectura de examen 2 operacion_Total = acumulativo + ExamN_1 + ExamN_2 -- calculo de nota total operacion_Promedio = operacion_Total / 4 -- calculo de promedio parcial imprimi_Total = Input.SetText("Input_Total4", operacion_Total) -- impriendo nota total inprimir_Promedio = Input.SetText("Input_Promedio4", operacion_Promedio) -- imprimiendo promedio parcial ------------------------------******************************------------------------------ ------------------------------******************************------------------------------




------------------------------*********COMUNICACIONES Y REDES*********------------------------------ acumulativo = Input.GetText("Input_Acum5")-- Variable para lectura de Acumulado ExamN_1 = Input.GetText("Input_Exam5") -- Variables par lectura de exanebn 1 ExamN_2 = Input.GetText("Input_Exam2_5") -- Variable para lectura de examen 2 operacion_Total = acumulativo + ExamN_1 + ExamN_2 -- calculo de nota total operacion_Promedio = operacion_Total / 4 -- calculo de promedio parcial imprimi_Total = Input.SetText("Input_Total5", operacion_Total) -- impriendo nota total inprimir_Promedio = Input.SetText("Input_Promedio5", operacion_Promedio) -- imprimiendo promedio parcial ------------------------------******************************------------------------------ ------------------------------******************************------------------------------ ------------------------------*********TALLER*********------------------------------ acumulativo = Input.GetText("Input_Acum6")-- Variable para lectura de Acumulado ExamN_1 = Input.GetText("Input_Exam6") -- Variables par lectura de exanebn 1 ExamN_2 = Input.GetText("Input_Exam2_6") -- Variable para lectura de examen 2 operacion_Total = acumulativo + ExamN_1 + ExamN_2 -- calculo de nota total operacion_Promedio = operacion_Total / 4 -- calculo de promedio parcial imprimi_Total = Input.SetText("Input_Total6", operacion_Total) -- impriendo nota total inprimir_Promedio = Input.SetText("Input_Promedio6", operacion_Promedio) -- imprimiendo promedio parcial

Les he colocado el script del botón calcular para que puedan apreciar cómo se desarrolla un script de cálculos avanzados de una manera clara y ordenada, los nombres de referencia de los objetos que podemos apreciar en las cadenas de comandos cambiaran por los nombres de sus objetos, de lo contrario les dará error este script. Script Botón Cancelar






Script Formulario





Ahora que tenemos todos estos programas creados quiere decir que ya has logrado manejar muy bien el desarrollo de estos formularios ahora iniciaremos un nuevo formulario y es el formulario de edición de información el cual se adaptara al formulario de consulta no es tan complicado de hacer ya que solo tendremos que crear un botón que diga Editar, y duplicaremos el formulario de ingreso y le pondremos por nombre Editar esto lo que ara es que en vez de mostrarte la información en el formulario de consulta te cargara un formulario en el cual podrás modificar los datos mostrados en él, tomaremos como ejemplo este mismo programa para ello en el formulario de consulta colocaremos un botón que diga Editar y dentro del colocaremos el script correspondiente. Script Script Botón Editar --[[fije el bNewRecord a falso, consiga el número seleccionado de la fila, y Salte al formulario de editar para corregir la información. Si no se selecciona nada, no haga nada.]]--

bNewRecord = false; tSelected = ListBox.GetSelected("nombre_List"); if tSelected then --ExpedienteID nRecordID = String.ToNumber(ListBox.GetItemData("nombre_List", tSelected[1])); Page.Jump("Editar")

end

Este es el script que agregamos y listo ya tenemos un formulario de Edición de Información de una manera rápida y fácil. Ahora en el formulario de edición de información deberemos de remplazar todas los ComboBox por Input para que podamos modificar la información de nuestros registros.





CAMPO TIPO DE CAMPO ANCHO CODIGO NUMERICO 6 NOMBRE TEXTO 40 APELLIDO TEXTO 40

PAIS TEXTO 25

CIUDAD TEXTO 25 TELEFONO_CASA NUMERICO 12 TELEFONO_OFICINA NUMERICO 12 CELULAR NUMERICO 14 FAX NUMERICO 12 EMAIL TEXTO 30 FACEBOOK TEXTO 30 CUMPLEAÑOS FECHA 8 SOBRENOMBRE TEXTO 15 COMENTARIO MEMO

Este programa será una agenda personal la cual contendrá todos los

formularios aprendidos, Menú, Ingreso, Consulta, Edición, aparte de ello en

el formulario de menú agregaremos una lista de verificación de ingreso de

datos, todo el diseño del formulario lo deberá de desarrollar según su

creatividad e ingenio.

Script






Script Lista de verificación






Script Botón Salir


Script Formulario








Script Formulario





Script Botón Editar Procedimiento: On Click Script Formulario de Edición Procedimiento: On Preload




Ahora que ya estamos desarrollando una serie de ejercicios más complejos procederemos a desarrollar un programa que cargue mediante una barra de progreso y que al llegar al 100% nos ejecute una acción, en el ejemplo que miraremos la acción a realizar en la apertura de una página web, en pantalla completa. Crearemos el formulario que se mire de la siguiente manera:

Una vez que lo tengamos listo

Procederemos a crear el script para que nuestra barra de progreso funcione

cuando presionemos el botón Cargar, para ello nos dirigimos a las

propiedades del botón cargar.




Script

Script Botón Cargar


--variable asignada para el conteo de posiciones de la barra de progreso posicion = 0; for contador = posicion, 101 do Progress.SetCurrentPos("Progress1", posicion); Progress.SetText("Progress1", posicion.."%"); posicion = posicion +1; if (contador > 0 and contador <=20) then Label.SetText("Label1", "20%"); elseif (contador > 20 and contador <= 40) then Label.SetText("Label1", "40%"); elseif (contador > 40 and contador <= 60) then Label.SetText("Label1", "60%"); elseif (contador > 60 and contador <= 80) then

Label.SetText("Label1", "80%"); elseif (contador > 80 and contador <= 90) then Label.SetText("Label1", "90%");

elseif (contador > 90 and contador <= 97) then Label.SetText("Label1", "97%");

elseif (contador > 97 and contador <= 100) then else Label.SetText("Label1", "100%"); end Application.Sleep(50); end File.OpenURL("http://www.alucardwarez.net", SW_MAXIMIZE);

Este es el desarrollo del script para que nuestra barra de progreso funcione correctamente como podemos apreciar utilizamos condiciones Si y Si Entonces para que nuestra barra de progreso funcione aparte de ello le




agregamos una cadena de impresión de texto en etiqueta para que dependiendo el porcentaje de carga nos lo imprima en la etiqueta llamada Label1 y cuando cargue al 100% ejecutara con nuestro navegador por defecto la dirección web escrita en la cadena de apertura de URL’s. La condición de si carga al 100% la podemos cambiar muy fácil mente por la que nosotros queramos la podríamos usar para nuestros formularios de ingreso o en donde mejor nos sea conveniente. Las barras de progreso son muy importantes a la hora de crear nuestros programas ya que estas nos indican el valor del porcentaje de nuestro proceso y nos indica si está por terminar de hacerlo o no, estas barras las podemos usar por ejemplo en programas de ingreso, logeo e incluso en programas de instalación que creemos. Ejercicio Desarrolle un programa el cual Guarde la siguiente Información:


CODIGO NUMERICO 6

FECHA_INSCRIP FECHA 8

NOMBRE_COMPANIA TEXTO 40

DIRECCION MEMO

CONTACTO TEXTO 40

TELEFONO NUMERICO 13

CELULAR NUMERICO 13

FAX NUMERICO 13

CREDITO_APROBADO TEXTO 2

TIEMPO_PAGO NUMERICO 3

LIMITE_CREDITO TEXTO 10

Este programa será para gestión préstamos bancarios el cual tendrá todos

los formularios necesarios tales como: Menú, Ingreso, Consulta, Modificar y

le agregaremos uno de búsqueda.




El programa deberá mirarse de la siguiente manera:

Formulario de Menú:

Script





Script

Script Botón Menús

Script Botón Agregar Compañía

Script Botón Consultar Compañía

Script Botón Buscar Compañía




Formulario de Ingreso:


Script Formulario





Formulario de Consulta:


Script Formulario





Formulario de Búsqueda:

Script Formulario de Búsqueda

Script Formulario





Formulario de Modificar:

Script Formulario de Modificar

Script Formulario





BASES DE DATOS EN SQLite 2 Creando varias Tablas en una Base de Datos

Las bases de datos en SQLite son una gran ventaja en el desarrollo de

software, pero una de las cualidades de las bases de datos es el soporte de

varias tablas dentro de ellas SQLite no se queda atrás con esta gran

flexibilidad nos da soporte para poder manejar todas las tablas que nosotros

queramos dentro de una misma base de datos, con esta gran utilidad

podremos desarrollar programas con diversas tablas.

¿De qué nos es de ayuda tener varias tablas en una base de datos?

Se preguntaran, pues esto es una gran ayuda a la hora de búsquedas de

información ya que las podemos hacer más rápidamente, tardaran menos

tiempo en encontrar una consulta y cargaran más rápido las tablas, ya que

cuando usamos una misma tabla para un sistema un poco grande a la hora

de hacer consultas o búsquedas tarda demasiado en cargar y eso se debe a

que debe de leer tantos campos y en cada uno de ellos esta guarda una

gran cantidad de información y eso retrasa las búsquedas

considerablemente esto sin tomar en cuenta que entre más sobre cargada

esta una base de datos más fácil mente se puede corromper y perderemos

toda la información guardada en ella.

Al momento de trabajar de esta manera con las bases de datos podemos

crear un sistema con varios formularios de ingreso, consultas, búsquedas, e

incluso podemos enlazar varios formulario para que podamos hacer

nuestros sistemas más complejos y con una mejor funcionabilidad, con

todas estas ventajas no podremos decir no puedo hacer esto en AMS, ya

que con estas grandes ventajas se darán cuenta que este es un potente

software de desarrollo no solo multimedia si no que podemos crear sistemas

iguales o mejores que los que se crean en Visual Basic, Visual FoxPro, C y

muchos más, aparte de ello a lo largo de este contenido se habrán

percatado que LUA es una mescla de diversos lenguajes de programación

que lo hacen un software de muy alta eficiencia.




Breve descripción de las cadenas de comandos para el desarrollo de las

bases de datos y las tablas:

SQLite.Open: Abre una base de datos/ Crea una base de datos

Application.GetLastError(): Verifica si hay algún error en el la apertura de

una base de datos.

SQLite.OK: Si existen algún tipo de error confirma los errores, mandando

un mensaje de error.

SQLite.Query: Cadena de comandos para crear una Base de datos con

Tablas.

CREATE Table: Crea la tabla dentro de una base de datos.

integer primery key: Agrega o indica el campo clave principal de la tabla.

bNewRecord: Apertura de un registro en blanco.

SQLite.QueryToTable: Lee la tabla seleccionada por el campo clave

principal.

Select * from: Selecciona una tabla.

where: este comando se adjunta a Select * from para seleccionar una tabla

por un campo.

insert into: Inserta o Guarda un valor en una tabla.

values: Guarda un valor en una tabla especificada.

insert or replace: Inserta o remplaza un valor en una tabla.

Estos son algunos de los comandos básicos en el manejo de las bases de

datos en SQLite, estos comandos debemos de manejarlos muy bien ya que

si nos los aprendemos podremos trabajar más fluidamente con nuestros

programas.




Ejemplo de una base de datos con dos tablas:

sDatabaseFile = _SourceFolder.. "\\Autoplay\\Docs\\Ejemplo.db";





end

SQLite.Query(db, "CREATE Table Alucard(RecordID integer primery key, codigo text,

nombre text)");

SQLite.Query(db, "CREATE Table Uriel(RecordID integer primery key, codigo text,

apellido text, edad text)");

Este es un ejemplo básico del uso de diversas tablas en una misma base de

datos como podemos ver no es nada difícil ya que solamente repetimos la

última fila de comandos y colocamos el nombre de la tabla y sus campos.

Les daré un ejemplo de un formulario de ingreso en el cual guardaremos los

mismos datos en dos tablas diferentes como sería el botón de guardar ya

que sería prácticamente lo mismo todo solo lo que cambiara será el botón

de guardar al cual se le agregaran dos filas más de cadenas.

scodigo = Input.GetText("Input_Codigo") snombre = Input.GetText("Input_Nombre") if bNewRecord then SQLite.Query(db,"insert into Alucard values(NULL, '"..scodigo.."', '"..snombre.."')"); SQLite.Query(db,"insert into Alucard2 values(NULL, '"..scodigo.."', '"..snombre.."')"); nLastError = Application.GetLastError(); if nLastError ~= SQLite.OK then Dialog.Message("Error:" ..nLastError, SQLite.GetLastErrorString()); end else




SQLite.Query(db,"insert or replace into Alucard values('"..nRecordID.."', '"..scodigo.."', '"..snombre.."')"); SQLite.Query(db,"insert or replace into Alucard2 values('"..nRecordID.."', '"..scodigo.."', '"..snombre.."')"); nLastError = Application.GetLastError(); if nLastError ~= SQLite.OK then Dialog.Message("Error:" ..nLastError, SQLite.GetLastErrorString()); end end

Como podemos ver no hay un cambio significativo en el desarrollo del botón

de guardar simplemente se adaptan dos cadenas más con los nombres de

las tablas y los campos de la tabla nueva y listo ya tenemos creado nuestro

formulario de ingreso de datos que guardara la información en dos tablas.

Si quisiéramos que nos guardara diferentes datos en las tablas por decir así

que en la tabla uno guarde una información y en la tabla dos guarde otra

solo debemos de modificar los campos que queremos que nos guarde en

cada una de ellas y listo.

Si queremos comprobar si nos ha guardado la información en las tablas solo

debemos de agregar un ListBox y crear el script correspondiente de

verificación de datos en las tablas de la siguiente manera es el mismo script

que hemos estado usando en los formularios anteriores con la única

diferencia que el hemos agregado las cadenas para que nos muestre la

información de las dos tablas en la misma lista el script es el siguiente.




Script Verificación de registros de dos tablas -- Borrar el contenido de todos los elementos de la página...

ListBox.DeleteItem("ListBox1", -1); -- Consulta la DB Alucard y almacena Todas las entradas en la Tabla Alucard y Alucard2

tInfo_List = SQLite.QueryToTable(db,"SELECT * FROM Alucard"); tInfo_List = SQLite.QueryToTable(db,"SELECT * FROM Alucard2"); nLastError = Application.GetLastError(); if nLastError ~= SQLite.OK then Dialog.Message("Error", SQLite.GetLastErrorString()); end -- si no hubo errores, continúe, de lo contrario no hace nada.

if nLastError == SQLite.OK then --recorrer la tabla

for nRow = 1,tInfo_List.Rows do --obtener el título del registro actual

nRecordID = tInfo_List.Data[nRow]["RecordID"]; scodigo = tInfo_List.Data[nRow]["codigo"]; snombre = tInfo_List.Data[nRow]["nombre"]; --Agregar el elemento a el Listbox = Codigo y Nombre ListBox.AddItem("ListBox1", nRecordID.. " ".. "Registros".. " : " .. scodigo.. " - " ..snombre.. " ", nRow); end end

Con este ejemplo de verificación de datos está muy claro cómo debemos de

realizar las verificaciones con dos o más tablas en una misma base de

datos como pueden ver no es complicado al contrario es muy fácil de

comprender y manejar, como he explicado a detalle desde el inicio del tema




de bases de datos en SQLite no me enfocare en explicar paso a paso los

ejercicios a continuación dejare una serie de sistemas que me tendrán que

desarrollar ustedes con varias tablas, los ejercicios contendrán dos o más

tablas, ya en este parte el tema de bases de datos se tornara un poco más

pesado ya que colocare sistemas más completos los cuales ustedes

deberán de desarrollar de la mejor manera posible.

Ejercicio

En este ejercicio me desarrollaran un sistema de control de matrículas para

una institución educativa el cual tendrá una serie de formularios que hemos

aprendido a desarrollar en las lecciones anteriores por lo tanto solo colocare

los tres formularios principales los cuales ustedes deberán de crear de la

misma manera como se muestran en las imágenes:

DISEÑO DE PANTALLAS - PANTALLA DE INICIO





Script





Script





Script

Script Formulario Logeo




AGREGAR PARTE I

Script Script Formulario Ingreso Encargado Procedimiento: On Preload




AGREGAR PARTE II

Script Script Formulario Ingreso Alumno/A Procedimiento: On Preload





Script Formulario







El anterior programa nos falta crear el formulario de impresión de datos el

cual no es nada difícil de hacer es el mismo formulario de modificación con

la única diferencia de que cambiaremos las cadenas de Input.SetText por

las de Label.SetTex, como nos podemos dar cuenta la segunda parte de las

cadenas no cambia solamente la primera que es la parte que enlaza la

cadena con el objeto de referencia no pongo ejemplo ya que simplemente

duplicaremos el formulario de modificar, y remplazaremos todos los objetos

que tengamos en nuestro programa como las Input, ComboBox, ListBox etc.

Por etiquetas que mantengan los mismos nombres que los archivos que

remplazaremos esto es para no tener que modificar todo el script de nuestro

formulario que si lo hiciéramos sería un trabajo largo y tedioso cosas que no

nos gustaría hacer, por lo tanto solo borraremos los objetos que no sean

etiquetas y serán remplazados por etiquetas (Label) para que cuando le en

la consulta seleccionemos un campo y le demos imprimir nos pegue la

información en ellas y podamos imprimir la información. Pero se

preguntaran de por qué hacer eso porque no imprimir directamente todo,

pues el pequeño detalle es de que no podemos imprimir esos objetos

directamente AMS es como Access y Visual que lo que hacen a la hora de

imprimir es una captura de formulario y lo imprimir directamente eso nos

lleva al gasto de tinta innecesaria por ello nosotros creamos esto de esta

manera para imprimir solamente lo que ocupamos, aparte de ello en visual y

Access para hacer una opción de impresión nos toma mucho tiempo digitar

todo el script para que funcione nosotros solo ocupamos esto Page.Print

esta es la cadena de comandos que ocupamos claro la complementaremos

con el resto de los argumentos, pero no sobrepasa una fila de script y con

eso nos podremos dar cuenta de la gran facilidad de impresión de

formularios que tenemos con este programa por ello no coloco ejemplos ya

que está de más ocupar hojas con algo que se comprende fácil mente, cabe

comentar que este script de impresión lo podemos colocar en el

procedimiento On Show o en On Click ya que si queremos imprimir todo de

un solo usamos On Show pero si queremos mirar primero como sale y luego

imprimir en On Click sería la opción más recomendada.




Ejercicio

En este ejercicio crearemos un programa que almacene información de

registro de páginas web el cual tendremos todos los formularios básicos

Menú, Ingreso, Comprobación, Consultas, Impresión, Modificar.

Para el desarrollo de este programa pondremos en práctica una nueva

opción que el conteo de registros para eso usaremos una script muy

peculiar la cual contara los registros ingresados en la base de datos que se

muestran en la ListBox de comprobación de datos y nos dará el numero

resultante en una etiqueta, el programa deberá tener la siguiente apariencia.

Este es solamente el formulario de ingreso usted deberá desarrollar con su

creatividad los demás formularios.

Aquí les dejo el script para el conteo se colocara en el procedimiento On

Show del formulario:




Script

Total = ListBox.GetCount("nombre_List");

Label.SetText("ID", Total);

Script


Script








Script

Script Formulario Ingreso Procedimiento: On Preload





Script Formulario





En este nuevo ejercicio crearemos un programa en el cual tendrá un

formulario de ingreso y dentro del mismo tendremos un sub formulario en el

cual también podremos agregar más información, como por ejemplo un

sistema bancario de depósito trabaja con sub formularios uno para verificar

los números de cuenta y el otro para realizar la operación, nosotros

crearemos uno no bancario pero sí que tenga la mayor similitud posible.

Crearemos un programa de ingreso de software, el cual tendrá un formulario

principal de ingreso y en el cual podremos agregar información adicional

que también será de mucha ayuda para la recopilación de datos del

personal.

En este caso crearemos tres tablas las cuales almacenaran toda la

información que ingresemos a nuestro programa, para ello podremos en

práctica lo que hemos aprendido, en el proceso de este programa

aprenderemos a utilizar una nueva herramienta la cual es la de los xDialog

la cual es una gran herramienta de ayuda a la hora de crear sub formularios

ya que estos diálogos tienen la capacidad de trabajar como formularios

normales pero con la gran ventaja que le podemos dar proporciones

diferentes que el resto del programa, esta es una de las mejores

características de esta herramienta pero hay un pequeño problema que

cuando tenemos abierto un dialogo no podemos trabajar en el formulario

principal pero si podemos agregar sub diálogos a nuestro dialogo y poder

trabajar con ellos con una gran flexibilidad.

La configuración de las dimensiones de los xDialog es la misma que la de

un formulario con la diferencia que en esta herramienta la configuramos

entrando a las propiedades de ella.




Nuestro programa tendrá tres tablas las cuales llamaremos Ingreso1,

Ingreso2, Ingreso3, y tendrán los siguientes campos cada una de ellas:

Ingreso1

SQLite.Query(db,"CREATE Table Ingreso1 (RecordID integer primary key,

Clave text, Nombre text, Version text, Categoria text, Fecha text, Licencia

text)");

Ingreso2


Ano text, Demo text, Freeware text, OpenSource text, Duraccion text)");

Ingreso3


Fabricante text, Programador text, Informacion text, Requerimientos text,

Web text, Soporte text)");

Una vez que ya tenemos las tablas creadas procederemos a crear los

formularios serán en total tres ya que tenemos tres tablas pero en el sub

formulario utilizaremos la opción de guardar la información del formulario en

dos tablas diferentes dividiendo la información en dos partes las cuales

serán la tabla2 y la tabla3, esto puede sonar un poco difícil pero uno de los

ejercicios anteriores se explicó cómo crear un botón que guardara la

información de un formulario en dos tablas por lo tanto aremos lo mismo

que en ese programa.




Formulario de Ingreso de Software

Como podemos apreciar en este formulario deberemos de cambiar el estilo

clásico de nuestros programas por este, es un poco más compacto y se ve

de una manera muy ordenada, las input les deberemos de cambiar el tipo

de borde por flat para que tomen esa apariencia, luego agregamos dos

combobox los cuales al seleccionar cualquiera de ellos nos cargara el

formulario con la información que queremos agregar, aparte de los objetos

estándar agregaremos dos chapas para darle la apariencia de cajas de

grupos con estas chapas lograremos este efecto de orden.

Formulario de Ingreso de Licencias




En este formulario utilizamos la misma apariencia que el anterior con el

único cambio de objetos de cajas de texto por combobox, usamos estos

objetos ya que nos dan una mayor rapidez a la hora de agregar información

ya que toda esta información es muy básica solo se seleccionara la opción

que se ocupa un SI o un NO, por lo tanto todos los combobox solo tendrán

dos datos SI, NO, esto nos facilitar el estar escribiendo si es o no es algo.

Formulario Ingreso Fabricante

En este formulario agregamos Input y ComboBox a la estructura

agrandamos dos Input para dar el espacio adecuado para poder agregar

información libremente en campos de tipo memo, una vez que tenemos esto

listo solo procederemos a crear todo el script correspondiente para este

programa.

En estas Input de Requerimientos e Información entraremos a las

propiedades de las input y le activaremos la caja de selección llamada

multilines la cual activara nuestra input para que podamos agregar texto en

múltiples líneas de texto.




SCRIPT Script Base de Datos

sDatabaseFile = _SourceFolder.. "\\Autoplay\\Docs\\Software.db";





end

SQLite.Query(db, "CREATE Table Control_Software1(RecordID integer primery key, Clave text,

Nombre text, Version text, Categoria text, Fecha text)");

SQLite.Query(db, "CREATE Table Control_Licencias(RecordID integer primery key, Ano text,

freeware text, Duraccion text, Demo text, OpenSource text)");

SQLite.Query(db, "CREATE Table Control_Caracteristicas(RecordID integer primery key,

Fabricante text, Programador text, Soporte text, Requerimientos text, Informacion text)");

Con esto tenemos listas nuestras tablas como podemos ver no es mucha la

diferencia de trabajar con uno o varias tablas a la vez, ahora continuaremos

con el script correspondiente a los de más formularios.

Nombres de las Tablas:

1- Control_Software

2- Control_Licencias

3- Control_Caracteristicas




Script Formulario de Ingreso Software

Script Formulario











Script Formulario de Ingreso Licencias

Script Formulario





Script Formulario de Ingreso Caracteristicas

Script Formulario












Script Lista de Verificación




Script Botón Nuevo Registro





Con el manejo de varias tablas en una misma base de datos se nos abre

una gran cantidad de posibilidades de desarrollar nuevos software con

mayor capacidad de almacenamiento, ya que cada tabla tiene la capacidad

de almacenar hasta 1.4 Tera Bytes de información, eso nos da una gran

capacidad de almacenamiento ahora agreguémosle a esto la capacidad de

almacenar hasta un máximo de 20 tablas por base de datos que es la

cantidad más o menos recomendable serian en total 28 Tera Bytes de

información, pero la recomendación que yo doy es que no excedamos de 5

tablas por base de datos ya que a la hora de indexar y consultar información

nos hace más lentas operaciones de consultas y búsquedas, recordemos

que entre más pesada sea una base de datos más tardara en hacer las

consultas.

Entre algunas cosas podremos realizar sistemas más grandes como por

ejemplo sistemas para instituciones educativas, supermercados, sistemas

de cobro, clínicas, almacenes, etc.




Back up de las bases de datos de un sistema

Este es un tema muy importante el poder hacer copias de seguridad de

nuestras bases de datos ya que cuando trabajamos con información suma

mente importante debemos de hacer nuestras copias de seguridad para

prevenir la pérdida total de información en algún problema del software o

hardware.

¿Qué es una copia de seguridad?, ¿Para qué me sirve el hacer una copia

de seguridad?, ¿Cómo se hacen las copias de seguridad?, ¿Qué benefician

obtengo por hacer esto?, estas suelen ser las preguntas que hacen cuando

estas desarrollando un sistema y debemos de responderlas adecuadamente

ya que un sistema que no tenga la posibilidad de hacer copias de seguridad

de sus bases de datos no cumple total mente las necesidades del cliente.

Cuando se trabaja con información con la cual tendremos que hacer

consultas, y pueden ser consultas de muchos años atrás y nuestras bases

de datos se han ido borrando por sobre peso u otras motivos que el usuario

solicite no podremos hacer uso de la información antigua de una empresa,

mientras que si se manejan copias de seguridad o respaldos como se les

suele llamar podremos acceder a información muy antigua de la empresa

para poder hacer uso de ella de una manera rápida y eficaz.

Como podemos hacer para agregar esa opción a nuestros sistemas

Para poder agregar esta función a nuestros sistemas lo único que tenemos

que hacer es agregar un nuevo formulario dentro de nuestro mismo sistema

en el cual incluiremos dos opciones Hacer copia de seguridad y Restaurar

base de datos, estas dos opciones son las básicas las cuales son

fundamentales, claro está que podemos agregar más opciones por ejemplo:

el guardar nuestra base de datos en una memoria USB directamente o

Guardarla en un Diskette, también podemos hacer que a la hora de hacer

nuestra copia de seguridad seleccionar donde la queremos guardar esta es

la manera más recomendable que yo puedo recomendar ya que todos




guardamos las cosas donde mejor nos convengan ya que si solo tenemos

un directorio predeterminado pero lo ocupamos guardar en otro lado lo

hacemos más directamente que estar guardando en un lado y luego entrar a

dicho directorio y copiar a nuestro nuevo directorio la copa de seguridad,

pero para eso es cuestión de gustos del usuario yo les enseñare una de

ellas, y espero les sea de mucha ayuda.

Script

Script del botón de Back up

sBackup=Dialog.FolderBrowse("Por Favor, seleccione una carpeta:",_DesktopFolder);

if(sBackup~="CANCEL") then

SQLite.Close(db);

File.Copy(_SourceFolder.."\\AutoPlay\\Docs\\BasedeDatos.db",sBackup,true,true,false,true,nil);

sDatabaseFile=_SourceFolder.."\\AutoPlay\\Docs\\BasedeDatos.db";

db=SQLite.Open(sDatabaseFile);

Dialog.Message("Proceso de copia de seguridad‖, ―La Copia de seguridad se ha completado con exito!",MB_OK,MB_ICONEXCLAMATION);

end

Como pueden ver el script es muy básico se le da una string a la función de

Dialog.FolderBrows la cual hace el papel de mostrar un mensaje de dialogo

con un árbol de directorios en el cual nosotros seleccionaremos donde

queremos guardar nuestra base de datos lo demás pues es solo una

condicional y un File Copy lo cual hace un copiado de la base de datos los

cuales están ubicados en la siguiente línea de comandos que indica el

directorio por defecto donde guardamos nuestras bases de datos, cuando

ha finalizado de copiar la base de datos manda un mensaje de

comunicando que la copia de seguridad a finalizado con éxito.




Script

Script del botón Restaurar Base de Datos

tRestore=Dialog.FileBrowse(true,"Locate File",_DesktopFolder,"All

Files(*.*)|*.*|","","dat",false,false);

sRestore=Table.Concat(tRestore,";",1,TABLE_ALL);

if sRestore~="CANCEL" then

SQLite.Close(db);

File.Copy(sRestore,_SourceFolder.."\\AutoPlay\\Docs\\",true,true,false,true,nil);

sDatabaseFile=_SourceFolder.."\\AutoPlay\\Docs\\BasedeDatos.db";

db=SQLite.Open(sDatabaseFile);

Dialog.Message("Proceso de restauración‖, ―Restaurar se ha completado con

exito!",MB_OK,MB_ICONEXCLAMATION);

end

Este es prácticamente el mismo que con la diferencia que este restaura

directamente al directorio por defecto nuestra base de datos simplemente

seleccionamos la base de datos que queremos restaurar y listo

automáticamente lo copiara a nuestra ruta por defecto.

Este es un tema relativamente corto ya que con estas script nosotros las

podemos tomar como base para poder desarrollar otro tipo de script para

realizar nuestros nuevos formularios de copias de seguridad, recuerda que

puedes colocar este script en el objeto que tú quieras no necesariamente un

botón, pero si utilizaras métodos más avanzados recuerda que el script

cambiara para que pueda adaptarse de una manera correcta al sistema.




BASES DE DATOS EN SQLite 3 Integrando nuevos objetos a nuestros formularios y manejo

De diferentes métodos de desarrollo de bases de datos.

En este capítulo veremos cómo desarrollar nuevas bases de datos

utilizando siempre SQLite, con las cuales interactuaremos con nuevos

objetos en nuestros formularios, en este tema manejare la relación de una

base de datos con un ComboBox en el cual se almacenara la información

ingresada en una ventana de dialogo, de igual manera se mostrara

automáticamente, y podremos modificarla y eliminarla si queremos.

Ejemplo

Esta es la apariencia que tendrá nuestro programa ahora procederemos a

crear nuestra base de datos.

Script Procedimiento Global Functions db = SQLite.Open("AutoPlay\\Docs\\pais.db"); myDBTable = "pais"; sQuery = "create table "..myDBTable.."(id integer primary key, pais text)"; SQLite.Query(db, sQuery);




Script Formulario Procedimiento On Show spaisQuery = "SELECT id,pais FROM "..myDBTable.." ORDER BY pais ASC"; tpaisQuery = SQLite.QueryToTable(db,spaisQuery); ComboBox.SetUpdate("ComboBox1", false); ComboBox.ResetContent("ComboBox1"); if tpaisQuery and tpaisQuery.Rows > 0 then for i=1,tpaisQuery.Rows do sID = tpaisQuery.Data[i]["id"]; spais = tpaisQuery.Data[i]["pais"]; ComboBox.AddItem("ComboBox1", spais, sID); end --forLoop else ComboBox.AddItem("ComboBox1", "DB EMPTY", ""); end ComboBox.SetUpdate("ComboBox1", true); ComboBox.SetSelected("ComboBox1", 1); npais = ComboBox.GetSelected("ComboBox1"); spais = ComboBox.GetItemText("ComboBox1", npais); sID = ComboBox.GetItemData("ComboBox1", npais); Input.SetText("Input1", spais); Label.SetText("ID", sID);

Script Boton Agregar Procedimiento On Click pais = Dialog.Input("Ingrese ", "Agregar un Pais a la Lista:", "", MB_ICONQUESTION); if pais ~= "CANCEL" then sQuery = "INSERT into "..myDBTable.." values(NULL,'"..pais.."')"; SQLite.Query(db,sQuery); nLatestID = SQLite.GetLastInsertRowID(db) spaisQuery = "SELECT id,pais FROM "..myDBTable.." ORDER BY pais ASC"; tpaisQuery = SQLite.QueryToTable(db,spaisQuery); ComboBox.SetUpdate("ComboBox1", false);




ComboBox.ResetContent("ComboBox1"); if tpaisQuery and tpaisQuery.Rows > 0 then for i=1,tpaisQuery.Rows do sID = tpaisQuery.Data[i]["id"]; spais = tpaisQuery.Data[i]["pais"]; ComboBox.AddItem("ComboBox1", spais, sID); end --forLoop else ComboBox.AddItem("ComboBox1", "DB EMPTY", ""); end ComboBox.SetUpdate("ComboBox1", true); nLatest = ComboBox.FindItem("ComboBox1", -1, LB_BYDATA, nLatestID); ComboBox.SetSelected("ComboBox1", nLatest); end

Script Botón Editar Procedimiento On Click

npais = ComboBox.GetSelected("ComboBox1"); sID = ComboBox.GetItemData("ComboBox1", npais); nSelect = npais; spais = ComboBox.GetItemText("ComboBox1", npais); spaisEdit = Dialog.Input("Editar Pais", "Pais:", spais, MB_ICONQUESTION); if spaisEdit ~="CANCEL" then sQuery = "UPDATE "..myDBTable.." SET pais='"..spaisEdit.."' WHERE id="..sID; SQLite.Query(db,sQuery); spaisQuery = "SELECT id,pais FROM "..myDBTable.." ORDER BY pais ASC"; tpaisQuery = SQLite.QueryToTable(db,spaisQuery); ComboBox.SetUpdate("ComboBox1", false); ComboBox.ResetContent("ComboBox1"); if tpaisQuery and tpaisQuery.Rows > 0 then for i=1,tpaisQuery.Rows do




sID = tpaisQuery.Data[i]["id"]; spais = tpaisQuery.Data[i]["pais"]; ComboBox.AddItem("ComboBox1", spais, sID); end --forLoop else ComboBox.AddItem("ComboBox1", "DB EMPTY", ""); end ComboBox.SetUpdate("ComboBox1", true); ComboBox.SetSelected("ComboBox1", npais); end

Script Botón Eliminar Procedimiento On Click

npais = ComboBox.GetSelected("ComboBox1"); nSelected = npais; sID = ComboBox.GetItemData("ComboBox1", npais); spais = ComboBox.GetItemText("ComboBox1", npais); nChoice = Dialog.Message("Confirmar", "esta seguro que quiere eliminar este registro?"..spais, MB_YESNO, MB_ICONQUESTION, MB_DEFBUTTON1); if nChoice == 6 then sQuery = "DELETE FROM "..myDBTable.." WHERE (id == " .. sID .. ")"; SQLite.Query(db, sQuery); spaisQuery = "SELECT id,pais FROM "..myDBTable.." ORDER BY pais ASC"; tpaisQuery = SQLite.QueryToTable(db,spaisQuery); ComboBox.SetUpdate("ComboBox1", false); ComboBox.ResetContent("ComboBox1"); if tpaisQuery and tpaisQuery.Rows > 0 then for i=1,tpaisQuery.Rows do sID = tpaisQuery.Data[i]["id"]; spais = tpaisQuery.Data[i]["pais"]; ComboBox.AddItem("ComboBox1", spais, sID);




end --forLoop else ComboBox.AddItem("ComboBox1", "DB EMPTY", ""); end ComboBox.SetUpdate("ComboBox1", true); ComboBox.SetSelected("ComboBox1", nSelected); end

Script ComboBox Procedimiento On Select

npais = ComboBox.GetSelected("ComboBox1") spais = ComboBox.GetItemText("ComboBox1", npais); sID = ComboBox.GetItemData("ComboBox1", npais); Input.SetText("Input1", spais); Label.SetText("ID", sID);

Con esto ya tendremos listo nuestro programa, y podremos agregar informacion a nuestra base de datos y nos la mostrara en el combobox, la cual podremos editar y eliminar de u na manera rápida y fácil.




EJERCICIO En este ejercicio realizaremos un programa que nos almacene los CD-Key de nuestro software, ya que como todos sabemos siempre perdemos nuestos cd-key cuando mas los necesitamos y por ello realizaremos una aplicación con la capacidad de almacenar esta información tan valiosa para nosotros, el formulario deberá de tener la siguiente apariencia. Como peden ver los objetos que agregamos son los mismos que hemos

venido utilizando, en este formulario le agregamos la opción de verificación

de ingreso de datos, pero en ella le agregaremos un script en el

procedimiento On Select, el cual cuando seleccionemos un cs-key nos

mostrara en las input la serial completa.

EJERCICIO En este ejercicio realizaremos un programa que nos almacene los CD-Key de nuestro software, ya que como todos sabemos siempre perdemos nuestos cd-key cuando mas los necesitamos y por ello realizaremos una aplicación con la capacidad de almacenar esta información tan valiosa para nosotros, el formulario deberá de tener la siguiente apariencia.




En esta aplicación continuaremos perfeccionando nuestro programa de

almacenamiento de cd-key ahora le hemos agregado la opción de guardar

también el nombre del programa ya que esta es una parte importante a

tomar en cuenta ya que si solo tenemos el cd-key, y no tenemos el nomebre

del programa es como que no tengamos nada por ello agregamos esta

opción a nuestra aplicación, aparte de ello agregaremos un buscador

incremental para nuestra aplicación para poder realizar búsquedas mas

rápidamente en nuestra aplicación.

EJERCICIO Almacenar y leer datos en un Array unidimensional Para almacenar y leer datos en los elementos de un Array unidimensional, deberá indicar el nombre del Array y la posición del elemento donde quiere almacenar los datos. Por ejemplo, si queremos una aplicación que permita almacenar en dos Arrays los nombres y apellidos de cien personas introducidas mediante cajas de texto diseñaríamos una aplicación similar a la siguiente:




Desarrolle todo el script para que esta aplicación pueda almacenar estos dis

campos los cuales son nombre, apellido y los muestre en el array una vez

guardados.

EJERCICIO Almacenar, leer, buscar y modificar datos en un Array unidimensional Para almacenar, leer, buscar y modificar datos en los elementos de un Array unidimensional, deberá indicar el nombre del Array y la posición del elemento donde quiere almacenar los datos. Por ejemplo, si queremos una aplicación que permita almacenar en dos Arrays los nombres y apellidos de cien personas introducidas mediante cajas de texto diseñaríamos una aplicación similar a la siguiente:

Desarrolle el script correspondiente para esta aplicación y que realice todas

las características que se piden.





En esta aplicación como podemos observar esta dedicada a almacenar

datos personales tomando de esa manera la orientación a una agenda

personal la cual nos será de mucha ayuda para poder tener mas ordenada

toda la información de nuestros contactos.






datos personales tomando de esa manera la orientación a una agenda

personal la cual nos será de mucha ayuda para poder tener mas ordenada

toda la información de nuestros contactos.

En este nuevo ejercicio agregaremos un buscador mas avanzado, y la

opción de poder eliminar contactos.




EJERCICIO Almacenar, leer, buscar y modificar datos en un Array unidimensional En el siguiente ejercicio crearemos una pequeña pantalla de ventas, donde podrá agregar productos y eliminarlos. También podrá buscar un elemento de la lista. Nota: este ejercicio no contiene una base de datos completa, es simplemente una simulación de un sistema de facturación para ingresar los productos.


datos de productos es un simulador de control de productos para un sistema

de ventas.




EJERCICIO Sistema de facturacion En el siguiente ejercicio crearemos sistema de facturación, en el cual podremos realizar ventas, almacenarlas, modificar facturas, imprimir facturas, entre otras cosas que se desarrollaran en clase. Diseño del formulario de Menu.




Diseño del formulario de Ingreso de facturas.




Diseño del formulario de Ipresion de factutas.

Los de más formularios los realizara a corde al formulario de facturación

crearemos también un formulario de recibos.

El formulario de recibos sirve para los clientes de crédito que realizaran

pagos a sus cuentas pendientes.




El formulario de recibos deberá tener el siguiente diseño.

El formulario de Consultas y Busquedas de Facturas deberá tener el

siguiente diseño.




El formulario de Consultas y Busquedas de Productos deberá tener el

siguiente diseño.

Cuando tengamos listo estos formularios realizaremos el scrip

correspondiente de cada uno de los formularios, recordemos que en este

ejrcicio relaizaremos varias tablas.




Manejaremos un control de productos el cual tendrá su propia tabla en la

que manejaremos el stock de productos de la empresa, el formulario esta

junto al mismo sistema de facturación.

El formulario de control de productos deberá verse asi.




MANEJO DE OBJETOS GRID CON BASES DE DATOS SQLite

Primero que nada definiremos que es una grid.

El objeto de la cuadrícula le permite agregar hojas de cálculo, rejillas y los

controles de lista a las aplicaciones. Si bien hay algunos ajustes que se

pueden configurar en tiempo de diseño, la mayoría de sus configuraciones,

incluso la carga de sus datos se manejan a través de acciones en tiempo de

ejecución. A pesar de que puede manejar la configuración de los datos en

una base por elemento, también puede utilizar la acción Grid.LoadFromFile

cargar objetos de un archivo de carácter delimitado, e incluso guardar

cualquier cambio realizado a través del objeto mediante la acción

Grid.SaveToFile.

El objetivo tiene una red de acción amplio conjunto incluyendo más de 110

actuaciones y dos eventos para que pueda cargar y manipular celdas en

tiempo de ejecución para una flexibilidad total.

El objeto también contiene una serie de propiedades visibles que pueden

ser controlados. Algunos de estos ajustes incluyen el color, la fuente, e

información sobre herramientas.

Definir un control Grid

Una cuadrícula contiene columnas que, a su vez, pueden contener encabezados y cualquier otro control. El control predeterminado contenido en una columna es un cuadro de texto, por lo que la funcionalidad predeterminada de la cuadrícula se aproxima a una ventana Examinar. Sin embargo, la arquitectura subyacente de la cuadrícula la abre hasta una extensión ilimitada.

El ejemplo siguiente crea un formulario que contiene dos objeto Grid uno de los objetos muestra las tablas de una base de datos y el otro objeto Grid muestra 5 columnas que en ellas se muestra la información guardada en la tabla seleccionada que en este caso la tabla es Alucard_Inventario.


http://msdn.microsoft.com/es-es/library/cc467842%28v=VS.71%29.aspx



Como pueden ver en este ejemplo se aplican dos objetos Grid los cuales

interactúan amigablemente con las bases de datos SQLite, podemos utilizar

los objetos Grid de muchas maneras no solo con las bases de datos pero en

esta ocasión solo aprenderemos como desarrollar este formulario de

consuta de datos que se muestra en la imagen superio.

EJEMPLO

Objetos a agregar: 2 Grid

Nombres de los Objetos:

Grid 1: grdTables

Grid 2: grdQueryResult




Ahora veremos las propiedades de cada una de las Grid.

Grid 1

Grid 2

Una vez que tengamos las grid configuradas de esta manera procederemos

a desarrollar el script de nuestro formulario y de la Grid 1 ―grdTables‖ ya

que en ella se aplicara una acción que cuando seleccionemos una de las

tablas que en ella se muestren nos mostrara la información en la Grid 2

―grdQueryResult‖.

Para ello entramos a las propiedades de la grid 1 y nos ubicamos en la

pestaña script y seleccionamos el procedimiento On Selection Changed y

colocaremos el siguiente script el cual hace que nos muestre la información

guardada en la tabla.




Script

if e_Row > 0 then sCurrentTable = Grid.GetCellText("grdTables", e_Row, e_Column) local tblReturn = SQLite.QueryToTable(dbHandle, "Select sql from sqlite_master where tbl_name = '"..sCurrentTable.."'"); if tblReturn.Rows > 0 then Grid.ExpandToFit("grdQueryResult", false, true) --encontrar el nombre de clave principal si hay una nPos = String.Find(tblReturn.Data[1]["sql"], "integer primary key", 1, false); if nPos > -1 then nBracket=String.ReverseFind(String.Left(tblReturn.Data[1]["sql"], nPos - 1), "(") nComma=String.ReverseFind(String.Left(tblReturn.Data[1]["sql"], nPos - 1), ",") if nComma > -1 then if nComma > nBracket then sPrimaryKey = String.Mid(String.Left(tblReturn.Data[1]["sql"], nPos - 1), nComma + 1, -1) else sPrimaryKey = String.Mid(String.Left(tblReturn.Data[1]["sql"], nPos - 1), nBracket + 1, -1) end elseif nBracket > -1 then if nBracket > nComma then sPrimaryKey = tring.TrimLeft(String.TrimRight(String.Mid(String.Left(tblReturn.Data[1]["sql"], nPos - 1), nBracket + 1, -1)," ")," ") else sPrimaryKey = String.TrimLeft(String.TrimRight(String.Mid(String.Left(tblReturn.Data[1]["sql"], nPos - 1), nComma + 1, -1)," ")," ") end end else sPrimaryKey = "" end -- Borrar e_Columns Grid.SetColumnCount("grdFields", 0); Grid.SetRowCount("grdFields", 0); Grid.Refresh("grdFields") --añadir e_RowID a la selección nCursor = SetCursor(32514) BindGrid(dbHandle, "grdQueryResult", "Select RowID, * from "..sCurrentTable); ReturnCursor(nCursor)




Grid.AutoSizeColumns("grdQueryResult", GVS_BOTH, true) Grid.SetGridLines("grdQueryResult", true, true) end end

Este es el script del objeto Grid1 ahora agregaremos el script del formulario.

Script Objeto: Formulario Procedimiento: On Preload n=0

Script Objeto: Formulario Procedimiento: On Show

OpenDB() sLastFolder = "Autoplay\\Docs\\Alucard.db" Grid.IsCellSelected("grdTables", 1, 1) Ahora agregaremos la función de la grid para ello nos dirigiremos a Global Functions

Script Procedimiento: Global Functions --[[ Función para abrir una base de datos SQLite y rellenar la cuadrícula de las tablas con los nombres de todas las tablas de la db. ]]— function OpenDB() tblDBName = _SourceFolder .. "\\AutoPlay\\Docs\\Alucard.db"; if tblDBName[tblDBName] ~= "CANCEL" then --abrir la db dbHandle = SQLite.Open(tblDBName) --Consulta la base de datos para los nombres de las tablas local tblTableNames = SQLite.QueryToTable(dbHandle, "SELECT * FROM sqlite_master WHERE type = 'table'"); --si hay tablas de la db if tblTableNames.Data and tblTableNames.Rows > 0 then --redes clara




Grid.DeleteAllItems("grdTables") Grid.DeleteAllItems("grdQueryResult") --Instalación de las mesas de cuadrícula con el número de filas --y las columnas para mostrar los datos Grid.SetRowCount("grdTables", tblTableNames.Rows + 1) Grid.SetColumnCount("grdTables", 1) Grid.SetFixedRowCount("grdTables", 1) --establecer el título filas fijado para un encabezado de columna Grid.SetCellText("grdTables", 0, 0, "Tablas", true) --rellenar la cuadrícula de los resultados de la consulta for i,v in pairs (tblTableNames.Data) do Grid.SetCellText("grdTables", i, 0, tblTableNames.Data[i]["name"], true) end --establecer la columna para rellenar la cuadrícula entera Grid.ExpandColumnsToFit("grdTables", true, true) --permitir la edición Grid.SetEditable("grdTables", false) --establecer la red a modo de lista Grid.SetListMode("grdTables", true) Grid.SetGridLines("grdQueryResult", false, false) Grid.SetRowCount("grdQueryResult", 1) Grid.SetColumnCount("grdQueryResult", 3) Grid.SetCellText("grdQueryResult", 0, 1, "Seleccione una tabla para mostrar sus datos") Grid.ExpandToFit("grdQueryResult", true, true) tblPath = String.SplitPath(tblDBName) sLastFolder = tblPath.Drive..tblPath.Folder end end end function BindGrid(dbHandle, sGridName, sQuery) bLoadingData = true; --conjunto de la red para volver a dibujar NO Grid.SetRedraw(sGridName, false, false) tblRS = SQLite.QueryToTable(dbHandle, sQuery) if tblRS ~= nil then if tblRS.Rows > 0 then -- Borrar columnas Grid.SetColumnCount(sGridName, 0);




Grid.SetRowCount(sGridName, 0); --Pegar Número de columnas y información de la cabecera Grid.SetColumnCount(sGridName, tblRS.Columns) --Ocultar la columna ROWID Grid.SetColumnWidth(sGridName, 0, 0, false) Grid.SetFixedRowCount(sGridName, 1) for nCols=1, tblRS.Columns do Grid.SetCellText(sGridName, 0, nCols -1, tblRS.ColumnNames[nCols], false) end --******************************-- --** Rellenar la cuadrícula con datos **-- --******************************-- --establecer el número de filas Grid.SetRowCount(sGridName, tblRS.Rows) --caminar por las filas for nRows=1, tblRS.Rows do --a pie de las columnas for nCols=1, tblRS.Columns do --establecer el texto de la celda Grid.SetCellText(sGridName, nRows, nCols - 1, tblRS.Data[nRows][tblRS.ColumnNames[nCols]], false); --establecidos par / impar color de la fila if nRows/2 == Math.Floor(nRows/2) then tblColors={Background=16777215,Text=0}; else --tblColors={Background=15395562,Text=0}; tblColors={Background=13369343,Text=0}; end Grid.SetCellColors(sGridName, nRows, nCols-1, tblColors, false) end end else nResult = Dialog.Message("Registro Empty Set", "La consulta no ha obtenido ningún resultado.", MB_OK, MB_ICONEXCLAMATION, MB_DEFBUTTON1) end else nResult = Dialog.Message("Registro Empty Set", "La consulta no ha obtenido ningún resultado.", MB_OK, MB_ICONEXCLAMATION, MB_DEFBUTTON1) end Grid.SetRedraw(sGridName, true, true) bLoadingData=false; end




--[[ Funciones del cursor ]] -- function SetCursor(cursor) -- Obtener actual del cursor local holdCursor = DLL.CallFunction(_SystemFolder.."\\User32.dll", "GetCursor", "", DLL_RETURN_TYPE_LONG, DLL_CALL_STDCALL); -- Carga hourglasscursor local hCursor = DLL.CallFunction(_SystemFolder.."\\User32.dll", "LoadCursorA", "0, "..cursor, DLL_RETURN_TYPE_LONG, DLL_CALL_STDCALL); -- Visualización cargado cursor local retVal = DLL.CallFunction(_SystemFolder.."\\User32.dll", "SetCursor", hCursor, DLL_RETURN_TYPE_LONG, DLL_CALL_STDCALL); --devolver el holdCursor return holdCursor; end function ReturnCursor(resCursor) -- Mostrar original del cursor local retVal = DLL.CallFunction(_SystemFolder.."\\User32.dll", "SetCursor", resCursor, DLL_RETURN_TYPE_LONG, DLL_CALL_STDCALL); end

Con esto tenenos lista ya nuestra función terminada y solo nos queda ejecutar el programa e ingresar datos a el para luego poder verlos en la consulta con las Grid. Ahora crearemos un sitema nuevo.




EJERCICIO En esta ocasión crearemos un sistema básico muy pequeño pero con todoas los formularios y agregaremos dos nuevos formulario que son el de reportes y el de Cuentas de usuario, los formuarios se verán de la siguiente manera. Formulario de Logeo En este formulario agregaremos una series de script nuevas a si que presten mucha atención en ellas, dentro del script esta la explicación de cada línea. Script Objeto: Boton Crear Cuenta Procedimeinto: On Click GetUsername = Input.GetText("Input1"); GetPassword = Input.GetText("Input2"); Register = INIFile.GetValue("AutoPlay\\Docs\\user.ini", "Account", "Password"); Register1 = INIFile.GetValue("AutoPlay\\Docs\\user.ini", "Account", "User"); if Register ~= "" and Register1 ~= "" then Dialog.Message("Ya está registrado", "Ya existe una cuenta registrada en este sistema", MB_OK, MB_ICONINFORMATION, MB_DEFBUTTON1); elseif GetUsername ~= "" and GetPassword ~= "" then




EncryptedUsername = Crypto.BlowfishEncryptString(""..GetUsername.."", "Username", 0); EncryptedPassword = Crypto.BlowfishEncryptString(""..GetPassword.."", "Password", 0); INIFile.SetValue("AutoPlay\\Docs\\user.ini", "Account", "User", EncryptedUsername); INIFile.SetValue("AutoPlay\\Docs\\user.ini", "Account", "Password", EncryptedPassword); Dialog.Message("Resultado", _tblErrorMessages[Application.GetLastError()]); Button.SetVisible("Agregar_btn", true); Button.SetVisible("Editar_btn", false); Button.SetVisible("Eliminar_btn", true); end

Script Objeto: Boton Eliminar Cuenta Procedimeinto: On Click INIFile.SetValue("AutoPlay\\Docs\\user.ini", "Account", "User", ""); INIFile.SetValue("AutoPlay\\Docs\\user.ini", "Account", "Password", ""); Button.SetVisible("Editar_btn", true); Button.SetVisible("Agregar_btn", false); Button.SetVisible("Eliminar_btn", false); Input.SetText("Input1", ""); Input.SetText("Input2", "");

Script Objeto: Boton Ingresar Procedimeinto: On Click GetUsername = INIFile.GetValue("AutoPlay\\Docs\\user.ini", "Account", "User"); DecryptedUsername = Crypto.BlowfishDecryptString(""..GetUsername.."", "Username"); GetUsername2 = Input.GetText("Input1"); -- changed this to check for blank username as well if DecryptedUsername ~= "" and GetUsername2 ~= "" and DecryptedUsername == GetUsername2 then GetPassword = INIFile.GetValue("AutoPlay\\Docs\\user.ini", "Account", "Password"); GetPassword2 = Input.GetText("Input2"); EncryptedPassword = Crypto.BlowfishEncryptString(""..GetPassword2.."", "Password"); -- changed this to check for blank password as well if GetPassword ~= "" and GetPassword2 ~= "" and GetPassword == EncryptedPassword then ----------------PROGRES------------------INICIO------------------------- posicion = 0; for contador = posicion, 101 do Progress.SetCurrentPos("Progress1", posicion); Progress.SetText("Progress1", posicion.."%");




posicion = posicion +1; if (contador > 0 and contador <=20) then Label.SetText("Label1", "Cargando archivos"); Image.SetVisible("Image13", true); elseif (contador > 20 and contador <= 40) then Image.SetVisible("Image13", false); Label.SetText("Label1", "Cargando Formularios"); Image.SetVisible("Image15", true); elseif (contador > 40 and contador <= 60) then Image.SetVisible("Image15", false); Label.SetText("Label1", "Reportes"); Image.SetVisible("Image16", true); elseif (contador > 60 and contador <= 80) then Image.SetVisible("Image16", false); Label.SetText("Label1", "Cargando Codigos"); Image.SetVisible("Image14", true); else Image.SetVisible("Image14", false); Label.SetText("Label1", "Carga completada"); end Application.Sleep(50); end ---------------PROGRES------------------FINAL--------------------------- Page.Jump("Menu"); else Dialog1 = Dialog.Message("Error", "Invalido password.\nPor favor intente de nuevo.", MB_OK, MB_ICONINFORMATION, MB_DEFBUTTON1); end else Dialog1 = Dialog.Message("Error", "Invalido username.\nPor favor intente de nuevo.", MB_OK, MB_ICONINFORMATION, MB_DEFBUTTON1); end ------------- cuenta administrador--------------------------- user_correcto = "admin" user_escrito = Input.GetText("Input1") pass_correcto = "admin" pass_escrito = Input.GetText("Input2") if user_correcto == user_correcto and pass_escrito == pass_correcto then Page.Jump("Menu") else




Dialog1 = Dialog.Message("Error", "Invalido Usurio ó Contraseña.\nPor favor intente de nuevo.", MB_OK, MB_ICONINFORMATION, MB_DEFBUTTON1); Page.Jump("Login") end

Script Objeto: Boton Salir Procedimeinto: On Click Application.Exit(0);

Script Objeto: Formulario Logeo Procedimeinto: On Preload Input.SetText("Input1", ""); Input.SetText("Input2", "");

Script Objeto: Formulario Logeo Procedimeinto: On Show Pag = Page.GetSize(); LblSize = Label.GetSize("Label4") HMov = "Dcha"; VMov = "Abajo"; Page.StartTimer(1);




Script Objeto: Formulario Logeo Procedimeinto: On Timer POS = Label.GetPos("Label4"); -- Sets way of movement if POS.X == 0 then HMov = "Dcha"; end if POS.X+LblSize.Width == Pag.Width then HMov = "Izq"; end if POS.Y == 0 then VMov = "Abajo"; end if POS.Y+LblSize.Height == Pag.Height then VMov = "Arriba"; end if HMov == "Dcha" then POS.X = POS.X + 1; Label.SetPos("Label4", POS.X, POS.Y); end if HMov == "Izq" then POS.X = POS.X - 1; Label.SetPos("Label4", POS.X, POS.Y); end




Con este tenemos listo el formulario de Logeo ahora continuaremos creando el formulario de menú.

Ahora el script para este formulario lo desarrollaran ustedes ya que en este

formulario se aplica lo aprendido en los temas anteriores.

Formulario Ingreso:




Formulario de Consulta Basico:

Formulario de Consulta con Grid:

En este formulario puedes hacer modificaciones a los registros directamente

en la grid solamente los seleccionas y podras modificar los datos los

cambios se guardaran automáticamente tras modificarlos.




Formulario de Reporte:

En este formulario tendremos que desarrollar una plantilla HTML para que

nos muestre la información como se muestra en la imagen, aparte de llo

hacemos uso de un dll externo para que nuestro programa interactue con

las bases de datos SQLite y el sistema HTML de nuestro programa, para

crear la plantilla solo debemos de utilizar cualquier programa editor de texto

que tengamos en nuestro ordenador y hacerla lo mas básica posible solo

con el titulo ya que la cuadricula y los colores se lo crearemos a puro código

HTML en una función que crearemos.

Alos archivos html que crearemos deberemos de colocarle por nombre

template1, template2.

Script Objeto: Formulario Reporte Procedimeinto: On Show Web.LoadURL("Web1", "AutoPlay\\Docs\\template2.htm"); -- Editar esta variable para trabajar con una base de datos diferente

-- Esta variable se pasa a la función como parámetro ParentRS ParentQuery = "Select Codigo, Descripcion, Cantidad, Fecha from Alucard_Inventario order by Codigo";




-- Llamado Mundial de funciones para crear una tabla HTML a partir de la consulta de SQLite

-- Si no deseas que ninguna de registros secundarios escriba "" para el parámetro ChildDB (un tercio) -- Parámetros --SQLiteToHTML(ParentDB as Database Handle, ParentRS as String, ChildDB as Database Handle, sFileOut as String) SQLiteToHTML(db, ParentQuery, "", "AutoPlay\\Docs\\Customers.htm"); -- Cerrar la conexión de base de datos ---SQLite.Close(db); -- Habilitar el control de explorador web, y los botones y la carga de la página web generada

Web.LoadURL("Web1", "AutoPlay\\Docs\\Customers.htm"); Button.SetEnabled("View_btn", true); Button.SetEnabled("Save_btn", true); Button.SetEnabled("Print_btn", true);

Script Objeto: Ver en Navegador Procedimeinto: On Click File.Open(_SourceFolder.. "\\AutoPlay\\Docs\\Customers.htm", "", SW_MAXIMIZE);

Script Objeto: Guardar Reporte Procedimeinto: On Click

result = Dialog.FileBrowse(false, "Guardar Como", _DesktopFolder, "All Files (*.*)|*.*|",

"Customers.htm", "htm", false, false);

File.Copy("AutoPlay\\Docs\\Customers.htm", result[1], true, true, false, true, nil);

Script Objeto: Imprimir Reporte Procedimeinto: On Click Web.Print("Web1", false)




Script Procedimeinto: Global Functions Datos: Esta función será para que cuando presionemos el botón de cerrar

nos muestre un mensaje advirtiendo si queremos cerrar nuestro programa.

--Función de aplicación de EXIT function QueryAllowProjectClose() result = Dialog.Message("Salir de la Aplicacion?", "¿Te gustaría salir de la aplicación?", MB_YESNO, MB_ICONEXCLAMATION, MB_DEFBUTTON1); --en el botón se ha presionado if result == 7 then --Cancelar Salir return false; else --permitir la salida return true; end end

Script Procedimeinto: Global Functions Datos: esta es la función de reporte

-------------------------REPORTE SITEMA-------------------------------------------------------- function RightAlignMenuItem(nNumItems) --hacer nNumItems que tiene un valor if nNumItems == nil then nNumItems = 0; end --hacer nNumItems que es numérico nNumItems = String.ToNumber(nNumItems); --llamar a la DLL n = DLL.CallFunction("AutoPlay\\Docs\\MenuHelper.dll", "RightAlign", Application.GetWndHandle()..","..nNumItems, DLL_RETURN_TYPE_LONG, DLL_CALL_STDCALL); end function SQLiteToHTML(ParentDB, ParentRS, ChildDB, sFileOut) --Poner la mesa formateo editando las variables de los valores por debajo local BorderColorSet = "#000000" local BorderWidthSet = "1"




local HeadBgColorSet = "#bcc5d0" local HeadFontSet = "Verdana" local HeadFontSizeSet = "4" local DetailBgColorSet = "#ffffff" local DetailFontSet = "Verdana" local DetailFontSizeSet = "2" --NO EDITAR - Formatos de las variables anteriores como html listo para combinar en el html principal. - NO EDITAR local BorderColor = "bordercolor=\""..BorderColorSet.."\"" local BorderWidth = "border=\""..BorderWidthSet.."\"" local HeadBgColor = "bgcolor=\""..HeadBgColorSet.."\"" local HeadFont = "<font face=\""..HeadFontSet.."\" size=\""..HeadFontSizeSet.."\">" local DetailBgColor = "bgcolor=\""..DetailBgColorSet.."\"" local DetailFont = "<font face=\""..DetailFontSet.."\" size=\""..DetailFontSizeSet.."\">" --FIN NO EDITAR local n; local strFile; local strHTML; local tblQ = SQLite.QueryToTable(db, ParentRS); --el progreso conjunto metros máximo y mostrar el metro StatusDlg.SetMeterRange(0, tblQ.Rows); StatusDlg.Show(0, false); if tblQ and tblQ.Rows > 0 then strHTML = "<table "..BorderWidth.." width=\"100%\" style=\"border-collapse: collapse\" "..BorderColor.." cellpadding=\"2\">\r\n"; --Encabezados de la columna strHTML = strHTML .. "<tr>\r\n"; for m=1, tblQ.Columns do strHTML = strHTML .. "<td "..HeadBgColor.." nowrap>"..HeadFont .. tblQ.ColumnNames[m] .. "</td>\r\n"; end strHTML = strHTML .. "\r\n</tr>"; --Llene la tabla for n=1, tblQ.Rows do strHTML = strHTML .. "<tr>\r\n"; for m=1, tblQ.Columns do strHTML = strHTML .. "<td "..DetailBgColor.." nowrap>"..DetailFont.. tblQ.Data[n][tblQ.ColumnNames[m]] .. "</td>\r\n";


end strHTML = strHTML .. "\r\n</tr>"; --Añadir celda que abarca todas las columnas para asegurar al niño la tabla registros if ChildDB ~= "" then --strHTML = strHTML .. "<td width=\"100%\" colspan=\""..tblQ.Columns.."\" bgcolor=\"#F9EFCA\">".."Order Details </td>\r\n"; --strHTML = strHTML .. "\r\n</tr>"; -Call the AddChildRec function to load in any child records. ChildHTML = AddChildRecs(ChildDB, "Select OrderID AS [Order ID], ShipName AS [Shipped To Name], Freight AS [Freight Charge] from Orders where CustomerID = \'"..tblQ.Data[n][tblQ.ColumnNames[1]].."\'"); if ChildHTML ~= nil then strHTML = strHTML .. "<td width=\"100%\" colspan=\""..tblQ.Columns.."\" bgcolor=\"#F9EFCA\">"..ChildHTML; end end --Actualización de metro de estado StatusDlg.SetTitle("Generating Report . . ."); StatusDlg.SetMessage("Generating Report . . . Please wait . . ."); StatusDlg.SetMeterPos(n); end strHTML = strHTML .. "</table>"; end --leer en el archivo de plantilla strFile = TextFile.ReadToString("AutoPlay\\Docs\\Template.htm"); --Buscar posición de la tabla, y se sustituye espacio reservado con tabla generada strFile = String.Replace(strFile, "", strHTML, false); --escribir en el fichero TextFile.WriteFromString(sFileOut, strFile, false); --Ocultar el contador Satus StatusDlg.Hide(); end function AddChildRecs(db, RS)



--Poner la mesa formateo editando las variables de los valores por debajo local BorderColorSet = "#000000"; local BorderWidthSet = "0"; local HeadBgColorSet = "#bcc5d0"; local HeadFontSet = "Verdana"; local HeadFontSizeSet = "1"; local DetailBgColorAlt1Set = "#ffffff"; --Para la fila alternativo sombreado local DetailBgColorAlt2Set = "#ffffff"; --Para la fila alternativo sombreado local DetailFontSet = "Verdana"; local DetailFontSizeSet = "1"; --NO EDITAR - Formatos de las variables anteriores como html listo para combinar en el html principal. - NO EDITAR local BorderColor = "bordercolor=\""..BorderColorSet.."\""; local BorderWidth = "border=\""..BorderWidthSet.."\""; local HeadBgColor = "bgcolor=\""..HeadBgColorSet.."\""; local HeadFont = "<font face=\""..HeadFontSet.."\" size=\""..HeadFontSizeSet.."\">"; local DetailBgColorAlt1 = "bgcolor=\""..DetailBgColorAlt1Set.."\""; local DetailBgColorAlt2 = "bgcolor=\""..DetailBgColorAlt2Set.."\""; local DetailFont = "<font face=\""..DetailFontSet.."\" size=\""..DetailFontSizeSet.."\">"; --FIN NO EDITAR local n; local strHTML; local DetailBgColor local tblQ = SQLite.QueryToTable(db, RS); if tblQ and tblQ.Rows > 0 then strHTML = "<table "..BorderWidth.." width=\"100%\" style=\"border-collapse: collapse\" "..BorderColor.." cellpadding=\"2\">\r\n"; --Añadir pequeña columna Encabezados strHTML = strHTML .. "<tr>\r\n"; for m=1, tblQ.Columns do strHTML = strHTML .. "<td "..HeadBgColor.." nowrap>"..HeadFont .. tblQ.ColumnNames[m] .. "</td>\r\n"; end strHTML = strHTML .. "\r\n</tr>"; --Llene la tabla secundaria for n=1, tblQ.Rows do strHTML = strHTML .. "<tr>\r\n";




--Aplicar alternativa fila sombreado OddEvenRow = Math.Mod(n, 2) if OddEvenRow == 0 then DetailBgColor = DetailBgColorAlt1 else DetailBgColor = DetailBgColorAlt2 end for m=1, tblQ.Columns do strHTML= strHTML .. "<td "..DetailBgColor.." nowrap>"..DetailFont.. tblQ.Data[n][tblQ.ColumnNames[m]] .. "</td>\r\n"; end strHTML = strHTML .. "\r\n</tr>"; end strHTML = strHTML .. "</table>"; end --Devuelve el HTML para generar la función de los padres return strHTML end

Con este script tendremos listo ya nuestro formulario de reportes el cual nos

será de mucha ayuda en nustros sistemas.




Con este último formulario hemos creado un sistema un poco más completo

aplicando todo lo aprendido y por ello podemos apreciar que nuestros

programas logran tener una mejor apariencia que al inicio, ahora puesto que

ya podemos manejar de una manera más completa las bases de datos en

SQLite y el manejo de ellas atreves de diversos tipos de formularios. Con

esta último ejercicio culmina la parte de manejo de bases de datos en

SQLite explicando cada uno de los procesos ahora solo quedan una serie

de ejercicios que nos ayudaran a mejorar más nuestras técnicas de

desarrollo de software.




Anexos TABLA DE VALORES ASCII

Códigos ASCII normales (códigos 0 - 127) 000

001 _

002 _

003 _

004 _ 005 006 007 •

008 009

010

011 _

012 _ 013

014 _

015 _

016 _

017 _

018 _

019 _ 020 ¶

021 §

022 _

023 _

024 _

025 _ 026

027 _

028 _

029 _

030 _

031 _

032 sp

033 !

034 "

035 #

036 $

037 %

038 &

039 '

040 (

041 )

042 *

043 +

044 ,

045 -

046 .

047 /

048 0

049 1

050 2

051 3

052 4

053 5

054 6

055 7

056 8

057 9

058 :

059 ;

060 <

061 =

062 >

063 ?

064 @

065 A

066 B

067 C

068 D

069 E

070 F

071 G

072 H

073 I

074 J

075 K

076 L

077 M

078 N

079 O

080 P

081 Q

082 R

083 S

084 T

085 U

086 V

087 W

088 X

089 Y

090 Z

091 [

092 \

093 ]

094 ^

095 _

096 `

097 a

098 b

099 c

100 d

101 e

102 f

103 g

104 h

105 i

106 j

107 k

108 l

109 m

110 n

111 o

112 p

113 q

114 r

115 s

116 t

117 u

118 v

119 w

120 x

121 y

122 z

123 {

124 |

125 }

126 ~

127 _

Códigos ASCII extendidos (códigos 128 - 255) 128 Ç

129 ü

130 é

131 â

132 ä

133 à

134 å

135 ç

136 ê

137 ë

138 è

139 ï

140 î

143 Å

144 É

145 æ

146 Æ

147 ô

148 ö

149 ò

150 û

151 ù

152 ÿ

153 Ö

154 Ü

155 ø

158 ×

159 ƒ

160 á

161 í

162 ó

163 ú

164 ñ

165 Ñ

166 ª

167 º

168 ¿

169 ®

170 ¬

172 ¼

173 ¡

174 «

175 »

176 #

177 &

178 *

179 .

180 0 181 Á

182 Â

183 À

184 ©

186 _

187 _

188 _ 189 ¢

190 ¥

191 '

192 +

193 /

194 1

195 2

196 4

197 5 198 ã

200 _

201 _ 202

203 !

204 $

205 (

206 , 207 ¤

208 ð

209 Ð

210 Ê

211 Ë

212 È

214 Í

215 Î

216 Ï

217 "

218 %

219 )

220 - 221 ¦

222 Ì

223 3 224 Ó

225 ß

226 Ô

228 õ

229 Õ

230 μ

231 þ

232 Þ

233 Ú

234 Û

235 Ù

236 ý

237 Ý

238 ¯

239 ´

240

242 _ 243 ¾

244 ¶

245 §

246 ÷

247 ¸

248 °

249 ¨

250 ·

251 ¹

252 ³

253 ²

254 6


Libro AMS 8_0 creado por Douglas A_ Rivera Castillo Edición Web

Documents

Transcript of Libro AMS 8_0 creado por Douglas A_ Rivera Castillo Edición Web