Para continuar con un poco más de Small Basic vamos a hablar de tres librerías: Program, Clock y Timer. No hay que olvidar que de momento Small Basic es un lenguaje en desarrollo y está en estado beta, por lo que existe la posibilidad de que ocurran fallos inesperados. Comento eso porque en el propio foro de ayuda algunas personas se quejaban de que la librería Timer a veces fallaba, pero al menos los dos ejemplos que encontraréis en este artículo os puedo garantizar que a mi me han funcionado.

En fin, pasando ya al tema en sí, la librería Program sirve para controlar aspectos relacionados con la ejecución del programa. Para ello tenemos dos operaciones y también una propiedad:

• Delay(milisegundos): Retrasa la ejecución del programa una cantidad determinada de milisegundos.
• End(): Termina la ejecución del programa.
• Directory: Permite obtener el directorio actual donde se está ejecutando la aplicación.

Y para poder comprenderlo un poco mejor aquí tenéis un ejemplo de las tres cosas:

'----------------------------------------------------
' Prueba del manejo de la ejecución
'----------------------------------------------------
TextWindow.Title = "Prueba del manejo de la ejecución"
TextWindow.WriteLine("Vamos a obtener el directorio del programa")
TextWindow.Write("Recibiendo información")
For i = 1 To 42
  Program.Delay(80)
  TextWindow.Write(".")
EndFor
TextWindow.WriteLine("")
TextWindow.WriteLine("")

TextWindow.WriteLine("El directorio es:")
TextWindow.WriteLine(Program.Directory)
TextWindow.WriteLine("")

While "true"
  TextWindow.Write("Mete un 0 para salir: ")
  aux = TextWindow.ReadNumber()
  TextWindow.WriteLine("Has metido un: " + aux)
  TextWindow.WriteLine("")
  If aux = 0 Then
    TextWindow.Pause()
    Program.End()
  EndIf
EndWhile

La siguiente librería que trataremos en este artículo es Clock, que básicamente sirve para acceder a la fecha y hora del reloj del sistema. Tiene diez propiedades, que son:

• Date: Permite obtener la fecha del sistema.
• Time: Permite obtener la hora del sistema.
• Year: Permite obtener el año.
• Month: Permite obtener el mes.
• Day: Permite obtener el día.
• WeekDay: Permite obtener el día de la semana.
• Hour: Permite obtener la hora actual.
• Minute: Permite obtener el minuto actual.
• Second: Permite obtener el segundo actual.
• Millisecond: Permite obtener el milisegundo actual.

Luego tenemos la librería Timer, que nos facilita la opción de poder repetir un fragmento de código, de nuestra aplicación, cada cierto intervalo de tiempo de forma indefinida. Por lo que nosotros indicaremos cuanto dura el intervalo de repetición y cada vez que pase esa cantidad fijada de tiempo, se lanzará un evento (este evento suele ser denominado como “Tick”), que Timer atrapará e invocará a la subrutina asociada a dicho evento. Esta librería tiene dos propiedades y dos operaciones:

• Interval: Permite obtener y cambiar el intervalo de repetición en milisegundos. Con ello podemos indicar con qué frecuencia será invocado el evento “Tick”. El valor que le pasemos tiene que estar en el siguiente rango: de 10 a 100000000.
• Tick: Permite cambiar la función que será invocada cada vez que se produzca el evento “Tick”.
• Pause(): Deja la librería en modo pausa, por lo que no se producirán más eventos “Tick” mientras estemos en ese modo.
• Resume(): Quita el modo pausa, permitiendo volver a generar eventos “Tick” de nuevo.

Y sabiendo todo lo que he expuesto en lo anterior, nos podemos hacer un bonito reloj como el que aparece en el siguiente ejemplo:

'----------------------------------------------------
' Prueba con el manejo del tiempo
'----------------------------------------------------
TextWindow.Title = "Prueba con el manejo del tiempo"
TextWindow.WriteLine("Formato estándar.")
TextWindow.WriteLine("Fecha: " + Clock.Date)
TextWindow.WriteLine("Hora:  " + Clock.Time)
TextWindow.WriteLine("")

TextWindow.WriteLine("Formato del usuario.")
TextWindow.Write("Fecha: ")
MostrarFechaCompleta()
TextWindow.Write("Hora:  ")
MostrarHoraCompleta()
TextWindow.WriteLine("")

Timer.Pause()
Timer.Tick = MostrarReloj
Timer.Interval = 100
Timer.Resume()

TextWindow.CursorLeft = 0
TextWindow.CursorTop = 22
TextWindow.Write("Pulse una tecla para salir...")
TextWindow.PauseWithoutMessage()
Program.End()

Sub MostrarFechaCompleta
  aux = Clock.Year + "-"
  aux = aux + Clock.Month + "-"
  aux = aux + Clock.Day + " "
  aux = aux + Clock.WeekDay
  TextWindow.WriteLine(aux)
EndSub

Sub MostrarHoraCompleta
  aux = Clock.Hour + ":"
  aux = aux + Clock.Minute + ":"
  aux = aux + Clock.Second + "."
  aux = aux + Clock.Millisecond
  TextWindow.WriteLine(aux)
EndSub

Sub MostrarReloj
  TextWindow.CursorLeft = 30
  TextWindow.CursorTop = 10
  MostrarHoraCompleta()
EndSub

En el próximo artículo lo más seguro es que comente alguna de las librerías para manejar estructuras de datos, posiblemente primero hable sobre manejar cadenas. Mientras tanto que lo paséis bien trasteando con los ejemplos.

Hoy empezaré hablando de como se utilizan los argumentos de la aplicación bajo Small Basic. Para ello tenemos la librería Arguments en el lenguaje. Esta sólo tiene una propiedad y un método, que son:

• Count: Permite obtener el número de argumentos, de línea de comando, pasados al programa.
• GetArgument(índice): Devuelve el argumento indicado por el índice que le demos. Hay que tener en cuenta que los argumentos del programa empiezan a numerarse desde el número 1 en adelante.

Así que sabiendo esto podemos manejar ya aplicaciones que puedan recibir argumentos de entrada, como ocurre con muchos de los programas que usamos diariamente. Y para poder verlo mejor, aquí teneis un ejemplo ilustrativo:

'----------------------------------------------------
' Prueba con los argumentos
'----------------------------------------------------
TextWindow.Title = "Prueba con los argumentos"
TextWindow.WriteLine("Has metido " + Arguments.Count + " argumentos.")

' Si se han pasado argumentos al programa, los mostramos por pantalla.
If Arguments.Count > 0 Then
  TextWindow.WriteLine("Lista de argumentos:")
  tab = "    "
  For i = 1 To Arguments.Count
    TextWindow.WriteLine(tab + Arguments.GetArgument(i))
  EndFor
EndIf

TextWindow.WriteLine("")

Hoy voy a hablar sobre la librería para manejar el modo consola en el lenguaje Small Basic. A parte de haber dejado un ejemplo de código al final del artículo, también lo he colgado en la web de microsoft para subir código, la dirección es esta. Como bien puse en el anterior comentario sobre las APIs, la librería para manejar el modo consola es TextWindow. Dentro de esta librería tenemos las siguientes propiedades:

• Title: Permite obtener y cambiar el título de la ventana.
• Left: Permite obtener y cambiar la coordenada X de la ventana.
• Top: Permite obtener y cambiar la coordenada Y de la ventana.
• CursorLeft: Permite obtener y cambiar la columna actual del cursor.
• CursorTop: Permite obtener y cambiar la fila actual del cursor.
• BackgroundColor: Permite obtener y cambiar el color de fondo del texto que escribamos en la ventana.
• ForegroundColor: Permite obtener y cambiar el color del texto que escribamos en la ventana.

Al final de la guía de introducción al Small Basic que hay en la página del proyecto, aparece una lista de los colores que soporta actualmente las APIs del lenguaje. Sin embargo para el modo consola, como es tradicional, solo soporta 16 colores, siendo los agraciados los siguientes: Black, DarkBlue, DarkGreen, DarkCyan, DarkRed, DarkMagenta, DarkYellow, Gray, DarkGray, Blue, Green, Cyan, Red, Magenta, Yellow, White.

Hay que tener en cuenta que si cambiamos el color de fondo, no se va a cambiar el fondo automáticamente. Se actualizará el color cuando borremos la pantalla entera o escribamos texto sobre esta. Por lo que vamos a echar un vistazo a las operaciones de la librería para saber qué podemos hacer:

• Show(): Muestra la ventana en modo consola, para permitir la interacción con ella.
• Hide(): Esconde la ventana, imposibilitando la interacción con ella.
• Clear(): Limpia el contenido de la pantalla, usando el color de fondo actual.
• Write(dato): Escribe en pantalla una cadena, número o el resultado de una expresión. Al contrario que WriteLine, esta operación no termina realizando un salto de línea, por lo que lo siguiente que vayamos a escribir en la ventana, salvo que cambiemos la posición del cursor, será escrito justo detrás de lo que acabamos de mostrar.
• WriteLine(dato): Escribe en pantalla una cadena, número o el resultado de una expresión. Al terminar de escribir en pantalla el texto, se producirá un salto de línea, de ese modo lo siguiente que se vaya a mostrar por pantalla se situará en el inicio de la siguiente línea de la consola.
• Read(): Lee una línea de texto introducida por teclado en la ventana y la devuelve. Esta función no terminará hasta que el usuario pulse la tecla ENTER.
• ReadNumber(): Lee un número introducido por teclado en la ventana y lo devuelve. Esta función no terminará hasta que el usuario pulse la tecla ENTER.
• Pause(): Muestra un mensaje y espera a que el usuario pulse una tecla, para poder continuar la ejecución del programa.
• PauseIfVisible(): Hace lo mismo que Pause() con la salvedad de que comprueba si la ventana no está escondida, pues en caso de estarlo no realizaría la pausa.
• PauseWithoutMessage(): Hace lo mismo que Pause() con la salvedad de no mostrar el mensaje por pantalla, para dar la oportunidad al programador de ser él, quien determine qué mensaje va a preceder a la pausa.

Y sabiendo esto ya podríamos echar un vistazo al programa de ejemplo que he colgado, pasando por alto las primeras 4 líneas de código que utilizan la librería de manejo de texto y que ya explicaremos en el futuro. Tan solo hay que saber, que esas líneas declaran 3 variables para contener 3 caracteres especiales que no tienen representación en las cadenas de Small Basic, salvo usando una variable como intermediaria. Pero ya hablaremos de ello más adelante. El ejemplo juega un poco con la posición del cursor, la de la ventana, los colores, las pausas y la entrada por teclado.

'----------------------------------------------------
' Prueba del modo consola con Small Basic
'----------------------------------------------------

comillas = Text.GetCharacter(34)                '\"
saltolinea = Text.GetCharacter(13)              '\n
saltolinea = saltolinea + Text.GetCharacter(10) '\r
tabulacion = Text.GetCharacter(9)               '\t

'----------------------------------------------------
' Prueba del hola mundo
'----------------------------------------------------
TextWindow.Title = "Prueba en modo consola"
TextWindow.BackgroundColor = "Black"
TextWindow.ForegroundColor = "Green"
TextWindow.CursorLeft = 10
TextWindow.CursorTop = 1
TextWindow.Write(comillas + "Hola mundo" + comillas)

TextWindow.ForegroundColor = "White"
TextWindow.CursorLeft = 0
TextWindow.CursorTop = 3
MostrarLeftTop()

TextWindow.Write("Mueva la ventana de la consola y ")
TextWindow.Write("pulse una tecla para continuar...")
TextWindow.WriteLine(saltolinea)
TextWindow.PauseWithoutMessage()

MostrarLeftTop()
TextWindow.Pause()

Sub MostrarLeftTop
  TextWindow.WriteLine("Left: " + TextWindow.Left)
  TextWindow.WriteLine("Top:  " + TextWindow.Top)
  TextWindow.WriteLine("")
EndSub

'----------------------------------------------------
' Prueba de colores en el modo consola
'----------------------------------------------------
TextWindow.Clear()
TextWindow.Write("Introduce una cadena: ")
cadena = TextWindow.Read()

TextWindow.CursorTop = 2
TextWindow.Write("Colores soportados en este modo:")
TextWindow.CursorTop = 4
TextWindow.CursorLeft = 0

color = "Black"
MostrarCadenaConColor()
color = "DarkBlue"
MostrarCadenaConColor()
color = "DarkGreen"
MostrarCadenaConColor()
color = "DarkCyan"
MostrarCadenaConColor()
color = "DarkRed"
MostrarCadenaConColor()
color = "DarkMagenta"
MostrarCadenaConColor()
color = "DarkYellow"
MostrarCadenaConColor()
color = "Gray"
MostrarCadenaConColor()
color = "DarkGray"
MostrarCadenaConColor()
color = "Blue"
MostrarCadenaConColor()
color = "Green"
MostrarCadenaConColor()
color = "Cyan"
MostrarCadenaConColor()
color = "Red"
MostrarCadenaConColor()
color = "Magenta"
MostrarCadenaConColor()
color = "Yellow"
MostrarCadenaConColor()
color = "White"
MostrarCadenaConColor()

TextWindow.WriteLine("")
TextWindow.Pause()

Sub MostrarCadenaConColor
  TextWindow.ForegroundColor = "White"
  TextWindow.Write(tabulacion + color + ": ")
  TextWindow.ForegroundColor = color
  TextWindow.CursorLeft = 21
  TextWindow.WriteLine(cadena)
EndSub

'----------------------------------------------------
' Prueba de la entrada de números
'----------------------------------------------------
TextWindow.Clear()
TextWindow.Write("Vamos a cambiar la posición de ")
TextWindow.WriteLine("la ventana." + saltolinea)

TextWindow.Write("Introduce la x: ")
x = TextWindow.ReadNumber()
TextWindow.Write("Introduce la y: ")
y = TextWindow.ReadNumber()

TextWindow.Left = x
TextWindow.Top = y

TextWindow.Write(saltolinea + "Y eso es todo por ")
TextWindow.WriteLine("ahora..." + saltolinea)

Y eso es todo por hoy respecto al manejo de la consola con Small Basic. El próximo día comentaré posiblemente el funcionamiento de algunas de las librerías del sistema o de manejo de estructuras de datos.