(00.20) Agregando entrada/salida en forma manual.En este post vamos a aprender muchas cosas, así que estemos atentos.

Como todavía no nos animamos a intercambiar datos entre
C y
JavaScript, vamos a seguir haciendo "simulaciones" de operaciones de entrada salida.
Tendremos el
control manual de dichas operaciones.
Vamos a declarar una variable global en
JavaScript llamada
signal_printf, de tipo booleana,
que será
true cuando haya nuevos datos para mostrar en el bloque
divprintf,
y será
false cuando no haya nuevos datos que mostrar.
Así, cada vez que nuestra
browcon haga sus famosos "refrescos" cada 3 segundos, entrando en la rutina
RefreshConsole(),
hará la consulta de si la variable
signal_printf es
true,
lo cual significará que habrá nuevos datos que mostrar.
En ese caso, se enviarán esos datos al bloque
divprintf para ser "publicados" allí.
Haremos esto con una función que llamaremos
post(),
que tomará como argumento una cadena de caracteres llamada
str.
Así, la llamada
post(str) agregará los nuevos datos al bloque
divprintf.
Una vez hecho esto, es claro que los "nuevos" datos ya dejaron de ser "nuevos",
pues ya han sido "publicados".
Así que ya no hay nada nuevo para publicar, y debe retornarse a
false el estado de la variable
signal_printf.
Veamos cómo queda la función
RefreshConsole() al agregarle esta nueva capacidad de reconocer cuándo publicar nuevos datos en
divprintf:
function RefreshBrowser() {
if (signal_divprintf) {
signal_divprintf = false;
post('Test divprintf. --- ');
};
if (show_divscanf) {
document.getElementById('divscanf').style.visibility = "visible";
} else {
document.getElementById('divscanf').style.visibility = "hidden";
}
}
Vemos que está casi igual que antes, salvo que ahora le hemos agregado una sentencia "if" al principio, para manejar el caso de
divprintf.
El texto que publicaremos es sólo una cadena de caracteres de testeo, que dice:
"Test divprintf. --- ".
Aquí observamos algo intrigante, y es que allí
hacemos primero el cambio de estado de la variable
signal_printf, poniéndolo a
false,
antes que la publicación propiamente dicha de la cadena test.
¿Por qué hemos invertido el orden de estas sentencias?
En primer lugar, analizándolo fríamente, el resultado final de las operaciones será el mismo, sin importar el orden en que las efectuemos, porque la función
post() no interferirá con la variable
signal_printf, y viceversa.
Pero la cuestión va más allá.
Tenemos que analizar lo que ocurre a lo largo de la línea temporal en que está abierta nuestra página
browcon.
Recordemos que cada 3 segundos la página intenta realizar persistentemente todas las tareas listadas en la función
RefreshConsole().
¿Qué ocurriría si la función no ha terminado de completar sus tareas antes de que pasen los 3 segundos?¡Se empezaría a ejecutar una nueva instancia de RefreshConsole() en simultáneo con la que todavía no terminó de ejecutarse! 
Aquí comienza a enredarse todo.
Por ejemplo, si la nueva instancia de
RefreshConsole() "ve" que el valor de la variable
signal_divprintf todavía tiene valor
true,
intentará publicar nuevamente los mismos datos que ya estaban siendo publicados por la instancia previa.
En resumen, se obtiene una duplicación en la salida de los datos, totalmente indeseable, por supuesto.
Para "defendernos" de esto, invertimos las sentencias,
de modo que el cambio de estado de la variable
signal_divprintf se realice
tan rápido como sea posible.
Lo más pronto que podemos hacer esto es en la primer sentencia dentro del bloque "
if".
Aquí podemos hablar de "
colisión de instancias", refiriéndonos a que un procedimiento colisiona con una nueva llamada de sí mismo, en superposición con una llamada anterior.
Si la velocidad de refresco fuese de 1 vez por cada milisegundo, entonces el riesgo de colisiones de instancias sería tan grande, que hasta podríamos tener decenas de instancias de
RefreshConsole() corriendo al mismo tiempo.
Más tarde procuraremos corregir este problema, pero la idea básica es la misma que esbozamos aquí,
es decir, la de "
informar prontísimo de un cambio de estado".
No hay muchas más opciones que esa en principio.
Tendremos que lidiar siempre con este problema de las "colisiones de instancias", de la función
RefreshConsole().
Pasemos a definir la función de publicación post().
Tiene una expresión muy sencilla, que mostramos de inmediato:
function post(str) {
document.getElementById('divprintf').innerHTML += str;
}
Lo que hace esta función es tomar el elemento
HTML con identificador
divprintf,
y allí le agrega la cadena de texto
str al contenido previamente existente.
El contenido de un bloque
div se puede obtener mediante el atributo
innerHTML.
Al invocarlo, se obtiene una
string (cadena de caracteres, cadena de texto), con el contenido completo que en ese momento hay dentro del
div.
Si le cambiamos el valor a dicho atributo, automáticamente hacemos que cambie el contenido de todo el bloque div.
Por ejemplo, una sentencia como la siguiente dejaría el bloque en blanco:
document.getElementById('divprintf').innerHTML = "";
Sin embargo, nosotros no queremos reemplazar lo que había antes en la
browcon, sino agregar los nuevos datos, tal como ocurre en la consola estándar de Windows.
Para agregar datos a lo que ya estaba de antes, se usa el operador de asignación incremental
+=, al cual le adosaremos la cadena
str, que es la que supuestamente contiene los nuevos datos a visualizar en pantalla.
Ahora tenemos que ocuparnos de permitir al usuario ingresar una línea de datos en forma de texto, desde el teclado, como en la consola estándar de Windows.
Más aún, queremos que cuando el usuario presione la tecla
Enter, los datos sean debidamente procesados.
Esto corresponde a una sentencia
scanf en
C.
Para esto, vamos a poner en el bloque divscanf un casillero rectangular que permita el ingreso de datos.
Esto se logra mediante un tag
input, más o menos así:
<div id="divscanf" style="visibility:hidden">
<input type="text" value="(Ingrese datos)" />
</div>
El casillero de texto es un tag
input con tipo
"text", como se puede apreciar.
Además, se le puede adjudicar un valor inicial con el atributo
value.
Le hemos puesto el texto
"(ingrese datos)", pero lo ideal es que ese campo esté vacío,
así que en el futuro pondremos
value="".
Eso ha sido muy fácil, pero el problema es que ese casillero de texto
no reacciona.

No hace nada aún.
Para que reaccione y sirva para enviar datos "hacia alguna parte", tendremos que cambiar la estructura del bloque
divscanf, haciendo uso más bien de los
formularios HTML.
El
formulario puede contener uno o más botones, así como texto y otros objetos.
Pero lo importante es que es capaz de reaccionar ante determinadas acciones del usuario,
como por ejemplo, presionar la tecla
Enter.
Nosotros utilizaremos un formulario cuyo único contenido es el casillero de texto arriba mencionado, para entrada de datos en forma de una línea de texto.
Además, a fin de poder interactuar con el formulario y con sus elementos internos, nos acostumbraremos a poner un identificador a todos estos elementos.
Por último, cuando el usuario presione la tecla
Enter, el formulario reaccionará y podrá ejecutar una acción.
Le indicaremos a
JavaScript que la acción a realizar será, en este caso, una función de
JavaScript contenido dentro del mismo documento, encargada de procesar los datos introducidos por el usuario.
Dichos datos están almacenados en el atributo
value del elemento con identificador
inputscanf, que será el nombre que daremos a nuestros casillero de texto.
El procesamiento de estos datos se hará con una función que llamaremos
senddata().
Y a fin de que el
formulario haga el llamado apropiado a esta función, cuando el usuario presione la tecla
Enter, tendremos que indicarlo dando al atributo
action del
formulario, el valor
"javascript:sendata(document.getElementById("inputscanf").value)".
Nos quedaría lo siguiente:
<div id="divscanf" style="visibility:hidden">
<form id='formscanf' action='javascript:senddata(document.getElementById("inputscanf").value);'>
<input id='inputscanf' type="text" value="" />
</form>
</div>
¿Qué hace la función
senddata()?
En el futuro, dicha función se encargará de exportar datos al "exterior" de la
browcon.
Por ahora no hace gran cosa.
Sin embargo, dicha función devolverá el
eco de los datos del usuario, reescribiéndolos en el bloque
divprintf, o sea, publicándolos en la
consola de salida de la
browcon.
También, tiene que reajustar el valor de la variable
show_divscanf a
false, para que, una vez que el usuario ha culminado la entrada de datos, el casillero de texto correspondiente quede oculto.
Otra vez, nos preocupa el fenómeno de "colisión de instancias" de RefreshConsole(), así que cambiamos el estado de la variable
show_divscanf tan pronto como sea posible.
El resultado final será esto:
function senddata(str) {
show_divscanf = false;
post(str+' ');
}
En todo esto faltaría un detalle elemental, y es que necesitamos avisarle a la browcon cuándo hay una solicitud de datos (
scanf).
Esto lo haremos manualmente haciendo click sobre un botón que diga algo como
"Get data from divscanf".
En este caso, y sólo en este caso, se pondrá el valor de la variable
show_divscanf a
true,
logrando que en el próximo ciclo de 3 segundos, en la llamada a
RefreshConsole(), aparezca mágicamente el casillero de texto para entrada de datos del usuario.
<input type="button" value="Get data from divscanf" onclick="show_divscanf = true;" />
La puesta a punto del script requiere que demos valores iniciales a las variables.
Inicialmente no hay datos que mostrar, ni tampoco datos que exportar, así que inicializamos las variables a
false.
signal_divprintf = false;
show_divscanf = false;
Ahora ya tenemos lista la interfase de nuestra browcon, funcionando correctamente los elementos encargados de la entrada y salida de datos.
Funciona bien, y podemos jugar libremente con los botones y el casillero de texto para ver qué pasa.
Pero recordemos que todavía funciona todo muy lentamente debido a que hay 3 segundos entre cada nueva acción.
Nombre de archivo: browcon00.20.htmlContenido:(browcon00.20.html)
<!DOCTYPE HTML>
<!--
BrowCon
Version: 00.20
-->
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
</head>
<body onload="setInterval('RefreshBrowser()', 3000);">
<script type="text/javascript">
signal_divprintf = false;
show_divscanf = false;
function post(str) {
document.getElementById('divprintf').innerHTML += str;
}
function senddata(str) {
show_divscanf = false;
post(str+' ');
}
function RefreshBrowser() {
if (signal_divprintf) {
signal_divprintf = false;
post('Test divprintf. --- ');
};
if (show_divscanf) {
document.getElementById('divscanf').style.visibility = "visible";
} else {
document.getElementById('divscanf').style.visibility = "hidden";
}
}
</script>
<div id="divcontrol">
<input type="button" value="Send data to divprintf" onclick="signal_divprintf = true;" />
<input type="button" value="Get data from divscanf" onclick="show_divscanf = true;" />
</div>
<br />
<div id="divprintf">
(Bloque para muestreo de datos con browcon_printf()...)
</div>
<br />
<div id="divscanf" style="visibility:hidden">
<form id='formscanf' action='javascript:senddata(document.getElementById("inputscanf").value);'>
<input id='inputscanf' type="text" value="" />
</form>
</div>
</body>
</html>
He aquí una captura de pantalla de unos experimentos que yo mismo hice.
La "foto" la tomé justo en el momento en que terminaba de introducir datos por 3era vez, tal que el eco de esos datos fue publicado, mientras todavía estaba visible el casillero de texto del bloque
divscanf, dado que aún no habían transcurrido los 3 segundos del ciclo.