Saltar al contenido

ESLE2 Visual

Ventanas, controles y dibujo

Documentación de ESLE2 Visual

Cómo hacer una ventana con botones, cajas de texto, listas y dibujos usando el mismo lenguaje SLE2 del curso. Escribí en el buscador del índice para filtrar: se ocultan los apartados que no tengan que ver con lo que buscás.

El entorno está en ESLE2 Visual. Los programas se guardan con extensión .slv. Si es la primera vez, empezá por El entorno, zona por zona: está toda la pantalla explicada con capturas.

Acá está el lenguaje. La interfaz —qué hace cada botón y cada panel— se explica con capturas en el botón Tutorial de ESLE2 Visual.

Qué es ESLE2 Visual

El lenguaje de siempre, con una biblioteca para la pantalla.

No es otro lenguaje

ESLE2 Visual no agrega ni una palabra reservada. No hay sentencias nuevas, ni tipos nuevos, ni una sintaxis nueva que aprender: todo lo visual son subrutinas predefinidas, igual que imprimir() o substr().

Eso quiere decir que lo que ya sabés sigue valiendo tal cual: si, mientras, desde, los vectores, los registros y tus propias subrutinas funcionan exactamente igual. Lo único que cambia es que ahora hay unas subrutinas más, y que en vez de escribir en la pantalla de texto, dibujan una ventana.

Qué se puede hacer

  • Ventanas con etiquetas, botones, cajas de texto, casillas, listas y deslizadores.
  • Responder a lo que hace la persona: un clic, un cambio, una tecla.
  • Dibujar en un lienzo: líneas, rectángulos, círculos, elipses, puntos y texto, con color y grosor.
Si buscás la pantalla de texto de siempre —imprimir(), leer(), colores y cursor— eso está en el IDE clásico y su documentación. Las dos cosas usan el mismo lenguaje.

La forma de un programa visual

Siempre los mismos cuatro pasos.

Los cuatro pasos

var
   b : numerico
inicio
   ventana ("Saludos", 380, 200)          // 1. abrir la ventana
   b = boton ("Saludar", 30, 60, 120, 34) // 2. crear los controles
   al_hacer_clic (b, "saludar")           // 3. quién atiende cada cosa
   esperar_eventos ()                     // 4. quedarse esperando
fin

subrutina saludar (id : numerico)
inicio
   mensaje ("¡Hola!")
fin
  1. La ventana se abre una sola vez, al principio.
  2. Los controles se crean con una subrutina que devuelve un número: ese número es el control, y hay que guardarlo en una variable para poder usarlo después.
  3. Los eventos se conectan a una subrutina tuya, por su nombre y entre comillas.
  4. esperar_eventos() deja el programa esperando.

Por qué hace falta esperar_eventos()

Un programa de consola empieza, hace lo suyo y termina. Uno con ventana no puede terminar: si terminara, la ventana se cerraría al instante y nadie llegaría a tocar nada. Por eso el programa se queda esperando, y cada vez que pasa algo el entorno llama a la subrutina que registraste, la ejecuta entera y vuelve a esperar.

Es exactamente lo que hace un entorno de escritorio cuando escribís Application.Run(...), con un nombre que se puede leer.

Si te olvidás de esperar_eventos(), la ventana aparece y desaparece: el programa llegó al fin y terminó. Es el error más común al empezar.

El número del control

Cada control que se crea devuelve un número, que se van dando en orden: el primero es el 1, el segundo el 2, y así. Guardalo siempre en una variable con un nombre que se entienda; usar el número a mano funciona, pero se rompe apenas agregás un control antes.

var
   nombre, aceptar : numerico
inicio
   ventana ("Datos", 400, 200)
   nombre = caja (20, 20, 200, 26)      // nombre vale 1
   aceptar = boton ("Listo", 20, 60)    // aceptar vale 2
   ...

Entregar la guía. Abajo del mensaje del profesor hay un botón: el alumno pone su nombre, el navegador corrige ahí mismo cada ejercicio de la guía y baja un archivo. El profesor junta todos los archivos en Ver entregas… y sale la planilla del curso, con un .csv para abrir con una planilla de cálculo. Como una guía es tarea y no un parcial, no hay cronómetro.

Modo examen

Un examen es un archivo. El profesor elige los ejercicios y cuánto dura —hay plantillas armadas: ventana y controles, eventos y datos, práctica rápida— y baja un archivo. El alumno lo abre desde Modo examen…, y el IDE se pone en modo examen: cronómetro arriba, sin la lista del curso y sin las soluciones.

Al entregar —o cuando se acaba el tiempo— el navegador corrige solo cada ejercicio con la misma verificación del botón Verificar, y baja una entrega con los resultados, el código escrito y los tiempos. El profesor la abre acá mismo y ve la planilla del curso.

No hay servidor: todo viaja en archivos. El examen no vigila a nadie —eso no se puede hacer honestamente sin uno—, pero deja constancia de qué se entregó y cuándo.

Modo aula: repartir una guía

En la vista Curso, el botón Modo aula… arma una guía: se marcan los ejercicios que entran, se le pone un título y un mensaje para la clase, y sale un enlace. Quien lo abre ve esa guía y nada más —la lista son esos ejercicios y arriba está el mensaje del profesor—, y cada uno se verifica solo, igual que siempre. Salir de la guía devuelve el curso completo.

La guía entera viaja adentro del enlace, después del #: no hay servidor, no hay cuentas, y no se guarda en ninguna parte. Un enlace se reparte por WhatsApp o se pega en el pizarrón, y sirve el día del parcial aunque se caiga todo lo demás.

Es el mismo modo aula del IDE de ESLE2. Los ejercicios de Visual se verifican por lo que el programa dibuja en la ventana, así que una guía de acá solo se abre en visual.html.

Diseñar la ventana arrastrando

Dos paneles. En «Diseño», un botón se arrastra a otro lugar y los dos números de su línea de código cambian. En «Ejecución», el botón cambia de color pero la línea de código queda igual y apagada.
Arrastrar en el diseñador cambia los números de tu programa y queda. Cambiar algo en las propiedades mientras el programa corre es para probar: se pierde en la próxima ejecución.

El botón Diseñar de la barra de herramientas (Ctrl + Shift + D) abre tu ventana a tamaño real y te deja acomodar los controles con el mouse, en vez de ir probando números hasta que queden derechos.

Lo que arrastrás cambia tu propio programa. No hay un archivo de diseño aparte: mover un botón cambia los dos números de su línea, y nada más de esa línea. Tus comentarios y tu sangría quedan como estaban, y con Ctrl + Z deshacés el arrastre entero de una.

Hay controles que se ven pero no se mueven, y están rayados: son los que tienen una variable o una cuenta en lugar de un número, como boton ("Ok", x, y + 10, 100, 30). Moverlos querría decir cambiar esa variable, que puede estar usada en otras diez líneas, así que el diseñador no la toca y te lo explica. Lo mismo con los controles que se crean adentro de un ciclo o de una subrutina: no tienen un lugar fijo hasta que el programa pasa por ahí.

Cuando agregás un control desde el cuadro de la izquierda, se escribe su línea antes de esperar_eventos () y se le declara una variable, para que puedas atenderle el clic con al_hacer_clic (). Y si borrás uno, se van también las líneas que le registraban eventos: si quedaran, el programa reventaría apuntando a un control que ya no existe.

Se usa sin mouse. Con Tab recorrés los controles —cada uno dice qué es, qué dice y dónde está—, las flechas lo mueven de a un píxel, con Shift de a diez, Alt + flechas lo estiran y Supr lo borra. También podés escribir los números a mano en el panel de la derecha.

La ventana

Dónde viven los controles.

Una ventana vacía con el punto (0, 0) en la esquina de arriba a la izquierda, una flecha «x» hacia la derecha y una flecha «y» hacia abajo, y un botón con sus medidas «ancho» y «alto» marcadas.
El (0, 0) está arriba a la izquierda y la y crece hacia abajo. Es al revés que en la clase de matemática, y es el error más frecuente las primeras veces.
SubrutinaQué hace
ventana (titulo, ancho, alto) Abre la ventana. El ancho y el alto son del área de adentro, en píxeles; si no se ponen, son 480 × 320. El mínimo es 120 × 90.
esperar_eventos () Deja el programa esperando: de acá no sigue hasta que se cierre la ventana. Va siempre al final del programa principal.
titulo_ventana (t) Cambia el título mientras el programa corre.
cerrar_ventana () Cierra la ventana y termina el programa.
mensaje (texto) Muestra un cartel con un texto y un botón para cerrarlo.

Las posiciones de los controles se cuentan desde la esquina de arriba a la izquierda del área de la ventana: x hacia la derecha, y hacia abajo.

Los controles

Los diez que hay, y cómo se crean.

Una ventana con una caja de texto, un desplegable, un campo numérico, una barra de progreso y un botón, cada uno señalado con el nombre de la subrutina que lo crea.
Los controles de formulario y la subrutina que crea cada uno. El desplegable ocupa el lugar de una sola línea; la lista, el de varias.

Crearlos

Todos devuelven el número del control. El ancho y el alto se pueden omitir: cada uno tiene el suyo de fábrica.

SubrutinaQué es
etiqueta (texto, x, y [, ancho, alto])Un texto fijo.
boton (texto, x, y [, ancho, alto])Un botón para tocar.
caja (x, y [, ancho, alto])Una caja de texto, vacía al principio.
casilla (texto, x, y [, ancho, alto])Una casilla que se marca y se desmarca.
lista (x, y [, ancho, alto])Una lista de opciones.
desplegable (x, y [, ancho, alto])Una lista que se abre al tocarla y muestra una opción por vez. Ocupa mucho menos que una lista.
numero (x, y [, ancho, alto])Una caja que solo acepta números enteros, con flechitas para subir y bajar.
progreso (x, y [, ancho, alto])Una barra que se llena de 0 a 100. Solo se mira: no se toca.
deslizador (x, y [, ancho, alto])Una barra para elegir un número de 0 a 100.
lienzo (x, y [, ancho, alto])Un rectángulo en blanco para dibujar.

Leerlos y cambiarlos

SubrutinaQué hace
poner_texto (c, texto)Cambia el texto de una etiqueta, un botón o una caja.
leer_texto (c)Devuelve el texto que tiene (lo que escribió la persona, si es una caja).
poner_valor (c, n) / leer_valor (c) El número de un deslizador o de un numero, cuánto se llenó un progreso, o cuál opción está elegida en un desplegable —contando desde 1, igual que los vectores de SL—.
rango_numero (c, minimo, maximo [, paso])Hasta dónde llega un numero. El paso es de a cuánto sube con cada flechita; de fábrica va de 0 a 100 de a 1.
cuantos_items (c)Cuántas opciones tiene una lista o un desplegable.
asociar_etiqueta (e, c)Le dice al navegador que esa etiqueta es el nombre de ese control. Es lo que hace que un lector de pantalla diga «Materia» al llegar al desplegable en vez de «lista, sin nombre».
enfocar (c)Manda el cursor a ese control. Devuelve TRUE si se pudo: un control escondido o apagado no recibe el foco.
marcar (c, TRUE) / marcado (c)Marcar una casilla y preguntar si está marcada.
agregar_item (c, texto)Agrega una opción a una lista o a un desplegable.
limpiar_items (c)Vacía la lista o el desplegable.
item_elegido (c)El texto de la opción elegida.
mover (c, x, y)Lo cambia de lugar.
redimensionar (c, ancho, alto)Le cambia el tamaño.
visible (c, TRUE/FALSE)Lo muestra o lo esconde.
habilitar (c, TRUE/FALSE)Lo deja usable o apagado.
color_fondo (c, r, g, b) · color_texto (c, r, g, b) Colores, de 0 a 255 cada uno.

Los eventos

Qué hacer cuando la persona toca algo.

Conectar un control con una subrutina

SubrutinaCuándo se dispara
al_hacer_clic (c, "sub")Al tocar un botón, una casilla, una etiqueta o el lienzo.
al_cambiar (c, "sub")Al mover un deslizador, elegir en una lista o marcar una casilla.
al_escribir (c, "sub")Cada vez que se escribe una tecla en una caja de texto.

La subrutina recibe el número del control que provocó el evento, así que una sola puede atender a varios:

   al_hacer_clic (mas, "mover")
   al_hacer_clic (menos, "mover")
   ...
subrutina mover (id : numerico)
inicio
   si ( id == 1 )
   {
      cuenta = cuenta + 1
   sino
      cuenta = cuenta - 1
   }
   poner_texto (3, str (cuenta, 0, 0))
fin

Si tu subrutina no necesita el número, podés declararla sin parámetros y funciona igual.

El nombre va entre comillas y tiene que existir: al_hacer_clic (b, "saludar"), no al_hacer_clic (b, saludar). Si el nombre no existe, ESLE2 te lo dice al ejecutar y te sugiere el parecido.

Los eventos se atienden de a uno

Mientras corre una subrutina de evento, los demás clics esperan su turno. No hay dos partes del programa corriendo a la vez, así que no hace falta pensar en eso.

Si adentro de un evento hay un error —una división por cero, un control que no existe—, el error se muestra en la ventana de salida y el programa se cierra, igual que en el IDE clásico.

Preguntar y esperar

Confirmar antes de hacer algo que no se puede deshacer.

La pregunta

Una ventana «Mis tareas» atenuada y, delante, un cartel que pregunta «¿Borrar todas las tareas?» con los botones No —con el cursor puesto encima— y Sí.
Mientras el cartel está abierto la ventana no se puede tocar, y el programa espera. El cursor arranca en No.

confirmar (pregunta) abre un cartel con Sí y No y detiene el programa hasta que la persona conteste. Devuelve TRUE o FALSE.

subrutina vaciar (id : numerico)
inicio
   si (confirmar ("¿Vaciar la lista?"))
   {
      limpiar_items (li)
   }
fin

Es la primera vez que escribís código que se frena esperando a una persona y después sigue. Mientras el cartel está abierto, la ventana no se puede tocar: es lo mismo que hace cualquier programa cuando te pregunta si querés guardar.

El cursor arranca en No, y Escape también contesta que no. No es casualidad: quien apura un Enter no tiene que borrar nada sin querer.

SubrutinaQué hace
confirmar (pregunta)Pregunta Sí o No y devuelve la respuesta. El programa espera.
mensaje (texto)Muestra un aviso. No pregunta nada y no espera.

El temporizador

Que algo pase solo, cada tantos segundos.

Un reloj que llama a una subrutina

Hasta acá todo pasaba porque alguien tocaba algo. El temporizador es lo que falta para un contador, un juego o una barra que avanza sola.

   t = temporizador (1000, "avanzar")
   activar_temporizador (t, TRUE)

Arranca apagado. Se crea primero y se prende cuando la ventana ya está armada: si empezara solo, el programa estaría haciendo cosas antes de terminar de dibujarse.

SubrutinaQué hace
temporizador (milisegundos, "subrutina")Crea el reloj y devuelve su número. Mínimo 50 milisegundos. Todavía no anda.
activar_temporizador (t, TRUE/FALSE)Lo prende o lo apaga. Apagarlo cancela también el tic que estuviera por venir.
temporizador_andando (t)Si está prendido. Sirve para un botón que hace Pausa y Seguir con el mismo código.

Dos cosas que conviene saber

Una línea de tiempo con tics azules parejos, un tramo gris marcado «en pausa» sin ningún tic, tics parejos otra vez después, y una cruz roja marcada «detener» sin nada después.
Los tics salen parejos. En pausa no hay ninguno, y al reanudar no se recuperan los que faltaron: después de «detener» no queda ninguno en camino.

No es un cronómetro exacto. Un temporizador de 1000 milisegundos llama a tu subrutina más o menos cada segundo: si el navegador está ocupado, llega un poco tarde. Para medir tiempo de verdad no sirve; para que algo se mueva, sí.

Nunca se te van a amontonar los tics. El próximo se agenda recién cuando el anterior terminó. Si tu subrutina tarda más que el intervalo, el reloj se atrasa — que es molesto— pero no se guarda los que faltaron para correrlos todos juntos, que sería imposible de entender.

Cerrar la ventana no para el reloj. Cerrarla la esconde, como cuando minimizás un programa: el tuyo sigue corriendo y la volvés a abrir con el botón Ventana tal como estaba. Para cortar de verdad está Detener, que apaga todos los temporizadores.

Dibujar en el lienzo

Líneas, figuras y texto con coordenadas.

Las órdenes

Todas reciben primero el número del lienzo. Las coordenadas se cuentan desde la esquina de arriba a la izquierda del lienzo, no de la ventana.

SubrutinaQué dibuja
pluma (l, r, g, b)El color de las líneas y los bordes.
relleno (l, r, g, b)El color con que se rellenan las figuras.
grosor (l, n)El grosor de la línea, en píxeles.
linea (l, x1, y1, x2, y2)Una línea de un punto al otro.
rectangulo (l, x, y, ancho, alto)Un rectángulo.
circulo (l, x, y, radio)Un círculo con centro en (x, y).
elipse (l, x, y, ancho, alto)Una elipse con centro en (x, y).
punto (l, x, y)Un punto suelto.
texto_en (l, x, y, texto)Escribe un texto adentro del dibujo.
borrar_lienzo (l)Deja el lienzo en blanco.
raton_x () · raton_y ()Dónde se tocó por última vez, dentro del control.

Un dibujo es una lista de órdenes

No hay más secreto: se elige un color de relleno, se dibuja una figura, se elige otro, se dibuja otra. El color queda puesto hasta que lo cambies, como si apoyaras y levantaras el pincel. Esta casa son doce órdenes y un desde para las ventanas.

Una ventana llamada La casa con un dibujo: cielo celeste, sol amarillo, una
                    casa con techo a dos aguas, puerta marrón y tres ventanas blancas hechas con
                    un ciclo.
Rectángulos, un círculo, dos líneas y un ciclo.

Dibujar con ciclos

Acá se ve para qué sirve lo que ya sabías: un desde dibuja cincuenta líneas sin escribirlas cincuenta veces.

var
   l, i : numerico
inicio
   ventana ("Abanico", 360, 300)
   l = lienzo (10, 10, 320, 240)
   pluma (l, 60, 110, 190)
   desde i = 0 hasta 20
   {
      linea (l, 10, 230, 10 + i * 15, 10)
   }
   esperar_eventos ()
fin

Dibujar cuando pasa algo

El lienzo también recibe clics: conectalo con al_hacer_clic y usá raton_x() y raton_y() para saber dónde tocó la persona.

   al_hacer_clic (l, "pintar")
   ...
subrutina pintar (id : numerico)
inicio
   relleno (id, 220, 80, 60)
   circulo (id, raton_x (), raton_y (), 10)
fin

El entorno, zona por zona

Qué es cada cosa de la pantalla y para qué sirve.

ESLE2 Visual es el mismo IDE que ya conocés: la misma cabecera, la misma barra de herramientas, los mismos paneles que se arrastran y se agrandan, el mismo curso. Lo distinto son tres cosas: el botón Ventana, que abre la ventana que construye tu programa; el panel Controles; y el menú Insertar.

La pantalla de ESLE2 Visual con seis zonas numeradas: la cabecera del sitio, la
                    barra de herramientas, el botón Ventana con su pastilla de dos controles, el
                    panel del programa, el panel Controles y el panel Salida.
La pantalla completa, con el programa ya corriendo. Los números están explicados abajo, y tocando cualquier captura de esta documentación se abre a tamaño completo.
  1. Cabecera del sitio. La misma de todas las páginas. A la izquierda, las dos mitades de esta: Diseñador (acá se programa) y Curso (los 50 ejercicios), y los enlaces al resto del sitio. A la derecha, tu racha, el progreso del curso, el buscador global (Ctrl + K), el modo presentación, los sonidos y el tema claro u oscuro.
  2. Barra de herramientas. Ejecutar (Ctrl + Enter) arranca el programa —y si ya había una ventana abierta, la cierra y vuelve a arrancar—; Detener (Esc) la cierra; Revisar busca errores y malas costumbres sin ejecutar nada; Depurar (F9) lo corre paso a paso. Y tres menús: Archivo, Insertar y Ver —donde está Ajustar texto (Alt + Z), que corta las líneas largas al ancho del panel sin perder la sangría.
  3. Ventana (Ctrl + Shift + V). El botón que abre la ventana de tu programa. Se abre sola la primera vez que el programa dibuja algo, y de ahí en adelante mandás vos. La pastilla dice cuántos controles hay adentro, así que se sabe que la ventana tiene algo sin abrirla, y el botón se enciende mientras el programa está vivo.
  4. El programa. El editor de siempre: colores, paréntesis emparejados, autocompletado y el número de línea y columna del cursor arriba a la derecha. Ahora se lleva la pantalla entera, que es donde se pasa el tiempo.
  5. Controles. A la izquierda, todo lo que el programa creó, en orden, con el número que le tocó a cada uno y su icono; tocá uno para seleccionarlo. A la derecha, su texto, su posición y su tamaño, que se pueden tocar para probar cómo queda: eso vale hasta la próxima ejecución. Para que quede, cambialo en el código.
  6. Salida. Lo que imprime el programa, los avisos, los errores y el resultado de verificar un ejercicio.
Los paneles se pueden agrandar arrastrando la barra que los separa (o con las flechas del teclado) y cambiar de lugar con el botón ⇅ de su encabezado. Ver → Restablecer los paneles los devuelve a su sitio.

La ventana del programa

El botón Ventana abre esto: la ventana de verdad que construye tu programa, sobre el fondo a cuadros que se lee como superficie de diseño. Los botones se tocan, las cajas se escriben, las listas se eligen y el programa responde, igual que una aplicación de escritorio.

La pantalla de la ventana: una ventana llamada Saludos con su barra de título,
                    una etiqueta que dice «Tocá el botón:» y un botón Saludar, sobre el fondo a
                    cuadros, con el botón Cerrar abajo a la derecha.
La ventana de ventana ("Saludos", 380, 200): el ancho y el alto son los del área gris de adentro, sin contar la barra de título.

Cerrar esta pantalla no corta el programa. La ventana sigue abierta —el estado dice esperando eventos, que es exactamente lo que hace esperar_eventos()— y volvés cuando quieras con el mismo botón. Para cortar el programa está Detener, o la ✕ de la barra de título de la ventana.

La ventana no se achica aunque la pantalla sea chica: mantiene el tamaño que le pediste y se puede desplazar. Es a propósito, porque las coordenadas de los controles son en píxeles y si cambiara de escala el dibujo dejaría de coincidir con el programa. En un teléfono es justamente por eso que conviene esta pantalla y no un panel: la ventana se ve entera en vez de espiada por una rendija.

El menú Insertar

Dos grupos: los controles, que crean algo en la ventana, y el dibujo, que son órdenes sueltas sobre un lienzo que ya exista. Al tocar uno, ESLE2 busca un nombre de variable que no estés usando (b, b2, b3…) y pega la línea completa donde tenés el cursor.

El menú Insertar abierto, con los siete controles —etiqueta, botón, caja,
                    casilla, lista, deslizador y lienzo— y las diez órdenes de dibujo, cada uno con
                    su icono dibujado.
Siete controles y diez órdenes de dibujo. Cada icono se dibuja con el color del texto, así que sigue al tema claro u oscuro.
No hay un diseñador que arrastre controles y reescriba el programa por atrás: el código manda. El menú pega código, nada más; después el botón Ventana muestra lo que ese código construye.

El panel Controles

El panel Controles: a la izquierda la lista con una etiqueta y un botón, cada
                    uno con su icono, y a la derecha las propiedades texto, x, y, ancho y alto del
                    botón elegido.
El botón elegido, con sus propiedades editables.

Sirve para entender qué número le tocó a cada control, que es lo que más cuesta al principio: la lista los muestra en el mismo orden en que los creó tu programa, y se puede mirar sin abrir la ventana.

Depurar paso a paso

Depurar (F9) marca la línea que se va a ejecutar y abre el panel Variables. Paso (F10) ejecuta esa línea; Continuar (F8) sigue sin pausas. Anda también adentro de un evento: se ve la subrutina del clic línea por línea, que es donde más cuesta entender qué pasó.

El depurador en pausa: la línea actual marcada en el editor y el panel
                    Variables mostrando el valor de n.
En pausa, con las variables vivas a la derecha.

La salida cuando algo sale mal

Los errores salen con el número de línea, qué pasó y —cuando ESLE2 puede adivinarlo— cómo se arregla. El cursor se va solo a la línea del problema.

El panel Salida mostrando un error: todavía no hay ninguna ventana, con la
                    sugerencia de llamar antes a ventana().
Crear un control antes de abrir la ventana: el error más común, con su arreglo al lado.

El curso de 50 ejercicios

Cómo se corrige solo un programa que no imprime nada.

Dónde está

En la pestaña Curso, arriba. Son 50 ejercicios en tres niveles, que van desde abrir una ventana vacía hasta un mini paint. Cada uno se abre en el diseñador con una plantilla para arrancar.

La pestaña Curso: a la izquierda la lista de ejercicios con su nivel, a la
                    derecha el enunciado de «Contador de clics», la pista, el botón Abrir en el
                    diseñador y la tabla que explica cómo se corrige.
La lista con los filtros por nivel, el enunciado, la pista y la tabla de casos.

Cómo se corrige

El curso de ESLE2 clásico compara lo que imprime tu programa con lo que se esperaba. Acá no hay texto que comparar: lo que hay es una ventana. Así que la corrección abre tu programa y lo usa.

  1. Ejecuta tu programa hasta que llega a esperar_eventos().
  2. Le da los toques que daría una persona: clic en el primer botón, escribir «Ana» en la primera caja, poner el primer deslizador en 42.
  3. Después revisa qué quedó: qué controles hay, qué dicen, dónde están, qué se dibujó, qué mensajes salieron.

Esas tres cosas son las tres columnas de la tabla Cómo se corrige que está en cada ejercicio: podés leer antes de escribir una línea exactamente qué se te va a pedir.

Los controles se cuentan por tipo y por orden de creación («el segundo botón»), nunca por el número interno. Si tu solución crea los mismos controles en otro orden de líneas, vale igual.

Lo que ves al verificar

Caso por caso, con el nombre del caso y —si falló— qué se esperaba y qué encontró.

La salida después de verificar: el caso 1 correcto y los casos 2 y 3
                    incorrectos, cada uno explicando que la primera etiqueta dice 0 cuando se
                    esperaba 1 y 5.
Un contador al que le falta actualizar la etiqueta: el caso 1 pasa y los otros dos dicen exactamente qué esperaban.

Cuando pasan todos, el ejercicio queda marcado, suma a la barra de progreso de arriba y cuenta para tu racha de días. El avance se guarda en este navegador; con Archivo → Exportar mi progreso te lo llevás a otra máquina, y ese archivo trae los tres cursos juntos (clásico, POO y Visual).

Todo lo demás de ESLE2

Lo que ya conocés del IDE clásico también está acá.

QuéDónde
Buscador global en todo el sitio Buscar, arriba a la derecha, o Ctrl + K.
Depurar paso a paso En la barra de acciones o F9. Paso (F10) ejecuta la sentencia marcada y Continuar (F8) sigue sin pausas. Las variables vivas aparecen a la derecha. Sirve también adentro de un evento: se ve la subrutina del clic línea por línea.
Simulador de memoria Ver → Simulador de memoria. Graba hasta que la ventana queda esperando: de ahí en adelante el programa ya no avanza solo.
Explorador de archivos Ver → Explorador de archivos. Viene apagado; encendido, trabajás con varios .slv a la vez, en carpetas.
Entrada de datos y argumentos La pestaña de al lado de Salida, abajo. Un programa visual puede seguir usando leer(), paramval() y pcount().
Archivos en memoria Archivo → Archivos en memoria…, para set_stdin() y set_stdout().
Cómo venís y repaso espaciado Debajo de la lista de ejercicios, en la pestaña Curso.
Autocompletado mientras escribís Solo, en el editor. Conoce las subrutinas visuales además de las del lenguaje.
Revisar sin ejecutar En la barra de acciones. No te avisa que «la subrutina nunca se llama» cuando la llama un evento: eso sería mentira en un programa visual.
Diagrama de flujo Ver → Diagrama de flujo. Elegí una rutina: cada evento es su propio diagrama.
Historial de versiones Ver → Historial. Guarda solo antes de cada ejecución y antes de cualquier cosa que pise el editor.
Modo presentación Ver → Modo presentación o Ctrl + ⇧ + P. Agranda la letra y saca los paneles laterales.
Tema claro y oscuro · sonidos Los dos botones de la derecha de la barra de menú.
Compartir el programa Archivo → Copiar enlace: el programa entero viaja adentro del enlace, sin servidor.
Instalar como aplicación Instalar, arriba a la derecha, donde el navegador lo permita. Después anda sin internet.
Dos cosas del IDE clásico no están acá, y es a propósito. Traducir a JavaScript o Python: esos lenguajes no tienen ventana() ni al_hacer_clic(), así que la traducción sería una mentira. Y el modo examen con mis ejercicios: se corrigen comparando la salida de texto, y acá lo que hay que comparar es una ventana. El curso Visual trae su propia corrección, explicada más arriba.

En el teléfono

La misma página, apilada: primero el programa y su ventana, y debajo el cuadro de herramientas, el explorador y la salida. Los botones crecen hasta poder tocarse con el dedo.

ESLE2 Visual en un teléfono: la barra de menú en una sola fila, las pestañas
                    del documento, la ventana del programa y, más abajo, el cuadro de herramientas
                    en dos columnas.
La misma pantalla en 380 píxeles de ancho.

La ventana que dibuja tu programa no se achica: mantiene el tamaño que le pediste y se puede desplazar. Es a propósito, porque las coordenadas de los controles son en píxeles y si cambiaran de escala el dibujo dejaría de coincidir con el programa.

Errores frecuentes

Lo que más pasa las primeras veces.

Qué pasaPor qué
La ventana aparece y desaparece Falta esperar_eventos() al final del programa principal.
todavía no hay ninguna ventana Se creó un control antes de llamar a ventana().
no hay ningún control con el número N Se usó una variable que no guarda ningún control, o el número a mano está corrido porque se agregó un control antes.
no hay ninguna subrutina que se llame … El nombre del evento está mal escrito o la subrutina no existe todavía.
El botón no hace nada Falta el al_hacer_clic, o se conectó a otro control.
Los controles se pisan Dos controles con la misma y: acordate de que el alto por omisión de un botón es 32 y el de una etiqueta 22.