Autor Tema: Interacción entre C y JavaScript+ActiveX (proyecto: usar navegador como consola)

0 Usuarios y 1 Visitante están viendo este tema.

10 Mayo, 2013, 06:52 am
Leído 6885 veces

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
El navegador como consola para programas hechos en C


Un programa GUI es todo aquel programa que abre una ventana en el escritorio de Windows, en general con fondo blanco, o mejor, del color que nosotros queramos, y aparecen allí diversos botones, cajas y listas con las cuales interactuar e intercambiar información. También puede que haya zonas donde editar texto, o tablas con celdas, o herramientas para hacer gráficos, insertar imágenes, sonidos, videos, enlaces a páginas web u otros archivos o programas, etc.

Los programas con interfase GUI son, por lo tanto, la mayoría de los programas que disfrutamos actualmente en nuestra computadora.
Uno de esos programas GUI son los navegadores de Internet más conocidos: Internet Explorer, Firefox, Opera, Chrome.

PERO cuando realizamos programas en C, en forma "común y corriente", no tenemos la comodidad de las interfases GUI.
El C "pelado" trabaja sólo con la consola de la línea de comandos.
Se nos abre entonces la ventana de comandos, que es ese rectángulo negro, feo, incómodo, cuyo tipo de letra es monoespaciado y anticuado. Es algo horrible, desagradable.

Sería muy deseable poder correr los programas que escribimos en C, usando una "alternativa" a la consola de comandos negra-fea-incómoda-horrible.

El primer problema que se nos presenta es que para hacer el más tonto programa con interfase GUI en Windows, tenemos que aprender a manejar alguna librería nueva y externa de C (como por ejemplo Tcl/Tk), o bien aprender a manejar las API de Windows, junto con técnicas de desarrollo de aplicaciones en C bajo Windows.

Lo ideal sería poder contar con una ventanita linda de Windows en la cual nuestros programas en C exhiban sus resultados, como si se tratara de la consola de comandos.
Se trataría de un emulador de la consola de entrada/salida estándar de C.

No sé si existen esa clase de emuladores,
pero aquí mostraremos cómo hacer para que el navegador funcione como consola de entrada/salida estándar para nuestros programas en C.  :o

La idea esencial es que esta interacción entre C y el navegador sea "transparente" no sólo para el usuario de nuestros programas, sino también para el programador.  ;) ;) ;)

¿A qué me refiero?
Bueno, la interacción de entrada/salida en C se hace básicamente a través de las funciones printf y scanf del lenguaje C.
Lo que haremos nosotros es crear unas funciones que tengan un nombre parecido, y que en vez de enviar o tomar datos de la consola de entrada/salida estándar, lo hagan hacia y desde el navegador.

Así, el programador no tiene que aprenderse ninguna cosa complicada nueva, el problema se reduce a la inclusión de un par de archivos (una librería y una página HTML), y más aún, es totalmente sencillo modificar un programa para que envíe y/o tome datos ya sea de la consola estándar o del navegador, según sea nuestro deseo.
Esto último es útil si queremos distribuir nuestro programa para dárselo a personas que sólo desean seguir usando su consola estándar, como han hecho toda la vida.

En los próximos posts daremos detalles del proyecto, la planificación, y finalmente la implementación real y definitiva.


10 Mayo, 2013, 06:32 pm
Respuesta #1

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
Proyecto de consola C/JavaScript

Nuestro proyecto se llamará:

BrowCon

Versión: 1.00


(BrowCon = Browser Console = Consola del navegador).

Constará de dos archivos:

* Una librería en C llamada browcon01.00.h
* Un archivo HTML llamado browcon0100.html, es decir, un documento que puede abrirse y procesarse con un programa navegador.

La librería browcon01.00.h contendrá dos funciones, o bien macros funcionales, llamadas browcon_printf y browcon_scanf, que se podrán usar exactamente de la misma manera que las respectivas funciones printf y scanf de la librería estándar stdio.h.

Por ejemplo, supongamos que queremos calcular la suma de 2 números, pero que los datos se vean y/o carguen en el navegador. Escribiríamos estas sentencias:

float a, b;
browser_printf("Introducir dos números separados por un espacio: ", "");
browser_scanf("%f %f", a, b);
browser_printf("Suma: %f + %f = %f", a, b, a+b);

En el navegador se verá lo siguiente:

Introducir dos números separados por un espacio: 2.84   0.17
Suma: 2.84 + 0.17 = 3.01

Además, temporalmente aparecerá un recuadro para que el usuario pueda cargar ahí los números que desee sumar (he puesto 2.84 y 0.17 sólo como ejemplos de datos de entrada).



El archivo browcon01.00.html contendrá una sección de código en lenguaje JavaScript.
En dicha sección se definirán funciones que controlen las operaciones básicas de la "browser console", tales como escribir datos en la ventana (del navegador) o leer datos de allí y guardarlos en algún lugar intermedio de almacenaje de datos, y hacer esto cuidando que la apariencia y comportamiento sea prácticamente igual al de un prograna en C "normal".

Como HTML es un documento con cierta estructura y estilos, tendremos que tomar decisiones sobre ambos.
El diseño será totalmente simplificado: visualmente, browcon será una página HTML en blanco, pero con un par de bloques div destinados a mostrar datos (browcon_printf) o esperar entrada de datos del usuario (browcon_scanf).

Vamos a llamar browcon no sólo a los archivos de nuestro sistema, sino también a esa especie de consola simulada en el navegador.

Hay dos características visuales básicas que queremos tener en cuenta:

(1) A medida que el programador va enviando datos a la browcon, nos gustaría que quede siempre visible "lo último" que hemos enviado, empujando hacia arriba los datos más viejos.
Para esto tendremos que definir un punto especial en el documento HTML a modo de "ancla", que siempre estará debajo del bloque destinado a muestreo de datos, y que funcionará así:
Una vez que hayamos mostrado los datos, haremos que el navegador vaya hasta el ancla.

(2) Cuando el programador desee que el usuario envíe ciertos datos desde la browcon, introduciéndolos en una línea de texto finalizada con la tecla Enter (del mismo modo en que funciona scanf en la consola de comandos), nos gustaría que aparezca claramente una línea para edición, rodeada quizás de un rectángulo delimitador, pero que se abra inmediatamente debajo de la última línea de datos mostrada por previas llamadas a browcon_printf y browcon_scanf.

La manera de implementar esto de un modo sencillo sería así: poner el bloque de introducción de datos siempre debajo del bloque de muestreo de datos.
¡Pero dejarlo invisible!  ;)
Cuando el programador, desde su programa en C, envíe una solicitud de datos con browcon_scanf, lo único que habrá que hacer será hacer visible por un ratito al bloque de introducción de datos, hasta que el usuario termine de escribir la información solicitada, tras presionar la tecla Enter.



Para hacer que una página web reaccione y realice operaciones complejas sobre sus elementos, es necesario utilizar código JavaScript.
A fin de no lidiar con decenas de archivos, nosotros pondremos todo junto en un mismo archivo: el contenido HTML y los scripts de JavaScript, así como los formatos en CSS, de haberlos, etc.
Esto además tiene sentido en nuestro proyecto, porque nuestra página HTML browcon tendrá muy pocos y sencillos elementos HTML.
La complejidad estará en los scripts.

Sin embargo, JavaScript tiene restricciones de seguridad bien concretas: es imposible leer o escribir datos desde una página web hacia y desde una computadora, usando JavaScript.
¡Pero printf y scanf son operaciones básicas de lectura/escritura de datos! ¿Cómo resolveremos esto?

Por suerte existe una librería que amplía las posibilidades de JavaScript, llamada ActiveX, que funciona en el navegador Internet Explorer de Microsoft.

Esto nos obliga de entrada a tener que utilizar el Internet Explorer  :o como único navegador admisible para nuestra browcon.

¡El proyecto browcon no funcionará en Firefox, Opera, Chrome, Netscape, ni ningún otro navegador!



Otro detalle importante de la implementación es que nuestra página HTML browcon tiene que estar siempre activa esperando alguna solicitud que pueda recibir externamente de mostrar o enviar información.

Lo más corriente sería intentar poner un ciclo del tipo "while", que ejecute siempre (hasta que se cierre el navegador), así:

while (true) {

   if ( Hay_Nueva_Solicitud() )
      Procesar_Solicitud();

}


¡Pero eso no funciona!

Aunque JavaScript cuenta con sentencias de tipo while, el efecto de poner un bucle while infinito (porque la condición es siempre "true" = "verdadera") en nuestra página HTML, es que el navegador quedará saturado, y nada funcionará.

Por lo tanto, la solución a este inconveniente tiene que tener otra "filosofía", a saber, la de "reaccionar ante interrupciones externas".
Sólo cuando desde el exterior se produce un cambio, nuestra browcon reaccionará y procesará una solicitud.
Para esto, lo que haremos será cargar un temporizador o cronómetro en el instante de inicio de nuestra página HTML browcon, y hacer que cada intervalos fijos de tiempo verifique si se han producido nuevas solicitudes de entrada/salida de datos.
En caso de detectar una solicitud, se la habrá de procesar, y si no, no se hace nada.

Esto es posible de hacer en JavaScript mediante la función setInterval, llamándola a través del atributo onload del elemento body de HTML.
 ??? ??? ???

En castellano:

El contenido de nuestra página web estará encerrado entre etiquetas <body> </body>, como es usual.
El elemento body tiene atributos, por ejemplo, onload.
Cuando asignamos a onload un valor, se interpreta como una acción a realizar por JavaScript al momento en que se carga la página.
Por ejemplo, onload="alert('Estoy cargando, no me interrumpas!!!')" hará saltar un mensaje de alerta, al momento de iniciar la carga de la página HTML.

En vez de eso, quisiéramos poner a punto el cronómetro, de tal manera que repita cierta acción a una frecuencia de una vez cada 3000 milisegundos (o sea 3 segundos).
En ese caso, la función JavaScript que debemos invocar es setInterval.
A dicha función tendremos que pasarle como argumento un comando o función de JavaScript, que en nuestro caso será un procedimiento encargado de revisar si hay o no nuevas solicitudes de entrada/salida, y en caso de haberlas, realizar las tareas necesarias en la browcon.

Ese procedimiento lo inventaremos nosotros, y le daremos el nombre de RefreshBrowcon().
¿Por qué ese nombre? Porque se encargará de "refrescar" el estado de la browcon, verificando si hay nuevas solicitudes de entrada/salida, y tomando las acciones pertinentes.

Nuestro elemento body tendrá ahora este aspecto:

<body onload=setInverval("RefreshBrowcon();", 3000)>

   (elementos de la browcon...)

</body>

Nuestro procedimiento RefreshBrowcon() tendrá este aspecto:

<script type="text/javascript">
    
    function RefreshBrowcon() {
          
             // Aún no hacemos nada...

    }

</script>




Hay otras consideraciones a tener en cuenta.

Debido a que lo normal es que en C la información se envíe a archivos de texto con caracteres ASCII, o con cualquier otra codificación "antigua", puede resultar incompatible el intercambio de datos con JavaScript, si es que éste envía información en formato Unicode ("moderno").

Aunque lo ideal sería "modernizar todo", en realidad es más fácil configurar HTML para que elija un formato de codificación "antiguo". Así, elegiremos el conjunto de caracteres ISO-8859-1.

Así, del lado de HTML/JavaScript/ActiveX, nuestra browcon tiene por ahora este aspecto:


<!DOCTYPE HTML>
<!--
      BrowCon
      Version: 00.00
-->

<html>

<head>

    <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">

</head>

<body onload="setInterval('RefreshBrowser()', 3000);">

   <script type="text/javascript">

       function RefreshBrowser() {    

         // Aún no estamos haciendo nada aquí...

       }

    </script>

   <div>
       (Bloque para muestreo de datos con browcon_printf()...)
   </div>
  
   <div style="visibility:hidden">
       (Bloque para introducción de datos con solicitudes browcon_scanf()...)
    </div>

</body>

</html>



He agregado un comentario al principio, indicando el número de versión del proyecto.
Como todavía es sólo un esqueleto, la versión es 00.00.
Le pondremos 01.00 cuando esté lista la primera versión funcionando correctamente.

Salvemos ese documento con el nombre browcon00.00.html, y luego abrámoslo con el navegador Internet Explorer (recordemos que tiene que ser ése navegador, y no otro).

Como todavía no hemos introducido ninguna herramienta ActiveX, da lo mismo abrirlo con cualquier otro navegador, pero nuestro proyecto finalizado necesita ActiveX, así que mejor acostumbrémonos a usar Internet Explorer.

Puede que nos aparezcan algunos avisos de seguridad, indicándonos que nuestro documento HTML tiene scripts, o incluso elementos de ActiveX.
Para que todo funcione, habrá que hacer click en "Permitir los scripts..." o "Permitir ejecución de ActiveX...", etc.

El lector podrá objetar que la velocidad de "refresco" elegida, de 3 segundos, es muuuuuy lenta.
De hecho, es muy conveniente una velocidad de refresco lento en la etapa de diseño y depuración de un proyecto que trabaja con la función setInterval().

Esto es lógico, porque si tuviéramos un error de programación, el persistente refresco, si fuera rápido, no nos daría tiempo a cerrar el navegador, ni intentar cualquier otra escapatoria...

En este proyecto tendremos muchos errores todo el tiempo hasta que quede a punto.
Así que: cuidado.  :o :o :o




Por último, observemos que el bloque destinado a introducción de datos por el usuario, está oculto mediante el atributo style="visibility:hidden".
En consecuencia, al cargar la página, ese bloque no se ve.


10 Mayo, 2013, 11:51 pm
Respuesta #2

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
(00.10) Mostrar u ocultar el bloque "scanf"

A partir de aquí vamos a dar nombres más concisos para las cosas que nos interesan.
Vamos a llamar output o bien consola (en modo) de entrada a las acciones de muestreo de datos, mediante funciones del tipo printf,
y llamaremos input o bien consola (en modo) de salida a las acciones de introducción de datos por parte del usuario, mediante funciones del tipo scanf.

Vemos que la consola de salida está siempre visible en la browcon, mientras que la consola de entrada aparece oculta.

Lo que haremos ahora es darle un identificador a cada una, denostando como divprintf a la consola de salida y con divscanf a la consola de entrada.

Además, definiremos en JavaScript una variable global show_divscanf, que tomará valores booleanos, es decir, true ó false (verdadero o falso), según que el bloque divscanf tenga que mostrarse o no.
Le daremos un valor inicial de false, de modo que al cargar la browcon, el bloque divscanf estará inicialmente oculto.

Ahora, haremos que la función de "refresco" RefreshConsole() verifique, cada vez que se la llama, es decir, paciente y repetidamente, cada 3 segundos, el estado de la variable show_divscanf.
Si tiene valor true (verdadero), entonces se hará visible el bloque divscanf,
y su tiene valor false (falso), el bloque divscanf se ocultará.

¿Cómo se logra esto de mostrar y ocultar?

Simplemente, hay que cambiar el valor del atributo style.visibility del elemento divscanf. El código para esto sería así:

       
              if (show_divscanf) {
                   document.getElementById('divscanf').style.visibility = "visible";
              } else {
                   document.getElementById('divscanf').style.visibility = "hidden";
              }


Lo que hacemos ahí es rastrear el elemento divscanf en nuestro documento HTML, mediante el método getElementById(), y modificamos su atributo de visibilidad, poniéndolo visible ("visible") u oculto ("hidden") según corresponda.
Ese código iría dentro de la función RefreshConsole(), como ya mencionamos.

Ahora, cada 3 segundos, JavaScript verifica si tiene que cambiar o no el mencionado atributo,
y eso produce el efecto de mostrar u ocultar el bloque divscanf.



El único problema es que no tenemos ninguna manera de hacer cambiar el estado de la variable show_divscanf.
Lo que necesitamos es que nuestra página reciba algún tipo de señal del exterior, y que reaccione cambiando enseguida el estado de la variable.

Por ahora no involucraremos acciones desde "afuera" de nuestro documento,
sino que nos conformamos por un rato con algún tipo de "simulación".
O sea, generaremos nosotros mismos la "señal de cambio de estado" haciendo clic en un botón que colocaremos en la parte superior de la página.

En tal caso, necesitaremos agregar un bloque HTML que contenga ese botón.
El botón se introduce mediante el tag input de HTML, seleccionando el tipo "button".

Al bloque o contenedor de este tipo de botones lo iremos modificando a lo largo de nuestro proyecto,
pero lo cierto es que siempre nos vendrá bien tener ahí un par de botones que nos permitan controlar un poco nuestra browcon.
Así, nos anticipamos a cualquier eventualidad futura, y le ponemos un identificador, digamos "divcontrol".

El botón tendrá un texto que informe en forma suscita que sirva para mostrar u ocultar el bloque divscanf.
Así que le pondremos el valor "Show/Hide divscanf".

Finalmente, necesitamos que el botón reaccione haciendo algo.
En concreto, queremos que nos sirva para cambiar el valor de la variable show_divscanf, y vaya alternando su valor de true a false y viceversa.
Esto se logra tomando la negación lógica del valor que previamente tenía, y asignando este nuevo valor a la variable.

Esta acción debe realizarse al momento que hagamos click sobre el botón.
Nuestro botón queda configurado así:


      <input
                 type="button"
                 value="Show/Hide divscanf"
                 onclick="show_divscanf = !show_divscanf;"
         />


Ya tenemos todas las modificaciones que deseamos agregar,
y nos queda lista entonces la versión 0.10 de nuestra browcon.

Cuando carguemos esta nueva versión en Internet Explorer,
seguramente estaremos tentados de hacer click en el nuevo botón que hemos creado.

¡Observaremos que la aparición o desaparición del bloque divscanf no es automático!

Esto es a propósito así, porque se parece a la situación real que manejaremos después,
mediante la cual JavaScript se entera de las señales enviadas desde el exterior sólo cada vez que se repite la llamada a RefreshConsole(), que en nuestro caso es cada 3 segundos.

Si cambiásemos la velocidad de refresco a 1 vez cada 1 milisegundo, entonces nos parecería que es automática la aparición o desaparición del bloque divscanf tras apretar el botón.
Pero no queremos este automatismo, porque puede traer conflictos al procesar señales así producidas desde el "exterior", de un modo más o menos impredecible.

El documento HTML tendrá ahora este contenido:

Nombre de archivo: browcon00.10.html

Contenido:


<!DOCTYPE HTML>
<!--
      BrowCon
      Version: 00.10
-->

<html>

     <head>
     
         <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
     
     </head>
     
     <body onload="setInterval('RefreshBrowser()', 3000);">
     
     
        <script type="text/javascript">
       
           show_divscanf = false;
     
     
           function RefreshBrowser() { 
             
              if (show_divscanf) {
                   document.getElementById('divscanf').style.visibility = "visible";
              } else {
                   document.getElementById('divscanf').style.visibility = "hidden";
              }
     
           }
       
        </script>
       
        <div id="divcontrol">
           
             <input type="button" value="Show/Hide divscanf" onclick="show_divscanf = !show_divscanf;" />
             
        </div>
     
        <div id="divprintf">
            (Bloque para muestreo de datos con browcon_printf()...)
        </div>
       
        <div id="divscanf" style="visibility:hidden">
            (Bloque para introducción de datos con solicitudes browcon_scanf()...)
        </div>
     
     </body>

</html>


He aquí una muestra de lo que se vería por ejemplo en Internet Explorer 10:


11 Mayo, 2013, 12:24 am
Respuesta #3

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
(00.11) Una pequeña mejora estética.

En la imagen del post anterior se puede apreciar que está todo muy pegado visualmente hablando.

Así que introduciremos un poco de separación entre los 3 bloques div de nuestra página, insertando simplemente una línea en blanco mediante el tag <br />.

Esto nos conduce a la versión 00.11 de la browcon, que pondré en Spoiler, porque es casi idéntica a la versión anterior, salvo por esta pequeña mejora estética.
Debajo, mostramos cómo luce la página visualmente tras el cambio.

Nombre de archivo: browcon00.11.html

Contenido:

(browcon00.11.html)

<!DOCTYPE HTML>
<!--
      BrowCon
      Version: 00.11
-->

<html>

     <head>
     
         <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
     
     </head>
     
     <body onload="setInterval('RefreshBrowser()', 3000);">
     
     
        <script type="text/javascript">
       
           show_divscanf = false;
     
     
           function RefreshBrowser() {   
             
              if (show_divscanf) {
                   document.getElementById('divscanf').style.visibility = "visible";
              } else {
                   document.getElementById('divscanf').style.visibility = "hidden";
              }
     
           }
       
        </script>
       
        <div id="divcontrol">
           
             <input type="button" value="Show/Hide divscanf" onclick="show_divscanf = !show_divscanf;" />
             
        </div>
        <br />
        <div id="divprintf">
            (Bloque para muestreo de datos con browcon_printf()...)
        </div>
        <br />
        <div id="divscanf" style="visibility:hidden">
            (Bloque para introducción de datos con solicitudes browcon_scanf()...)
        </div>
     
     </body>

</html>

[cerrar]



11 Mayo, 2013, 02:30 am
Respuesta #4

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
(00.20) Agregando entrada/salida en forma manual.

En este post vamos a aprender muchas cosas, así que estemos atentos.  :o

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!  :o

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.html

Contenido:

(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>



[cerrar]


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.


11 Mayo, 2013, 03:45 am
Respuesta #5

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
(00.21) Mejorando detalles

Si bien nuestra browcon está bastante funcional, tiene varios defectos pequeños, que ahora procuraremos corregir.

Si jugamos con nuestra browcon para ingresar datos repetidas veces,
veremos que, al hacerse visible el bloque divscanf, el casillero de texto inputscanf aparece con el último texto que habíamos introducido antes.  :-\

Esto es desprolijo, y nos gustaría que cada vez que se active el casillero inputscanf, aparezca vacío de contenido.
Para lograr esto, hay que tener en cuenta que el contenido de ese casillero está contenido en el atributo value del elemento inputscanf.
Así, antes de hacerlo visible, lo forzaríamos a que tenga el atributo value="".
Esto se haría, agregando la siguiente sentencia


      document.getElementById('inputscanf').value = '';


¿Dónde?   ???

Esa acción debe realizarse en el momento que hacemos click en el botón "Get data...",
y justo antes de activar la variable show_divscanf.
Así que tendremos que agregar esto al atributo onclick del botón, así:


             <input type="button" value="Get data from divscanf" onclick="document.getElementById('inputscanf').value = ''; show_divscanf = true;" />


Notemos que el borrado del campo value se realiza justo antes de una nueva entrada de datos.
Mientras tanto, el valor antiguo que había, quedará ahí, aún en el caso de que el bloque divscanf quede oculto.

Podríamos también, por fanatismo, limpiar el campo value justo después de haber realizado el eco, de los datos ingresados, en el bloque dviprintf.
En tal caso, tendríamos que agregar otra vez la misma sentencia al final de la función senddata().


           function senddata(str) {
                show_divscanf = false; 
                post(str+' ');
                document.getElementById('inputscanf').value = '';
           }


Notemos que desde la versión 00.20 estoy enviando el eco de divscanf mediante la sentencia: post(str+' ').
¿Cuál es la gracia de "sumar" el caracter espacio en blanco mediante +' '?
Eso lo hago para que haya un mínimo de separación entre sucesivos ecos...
Si no, quedaría muy desprolijo.

Como sea, ahora el casillero de texto se borrará inmediatamente tras publicarse el eco en divprintf.
Ya no habrá que esperar hasta la próxima entrada de datos.



Otro detalle que nos gustaría cambiar es la longitud del casillero de texto inputscanf.
Eso es sencillo, cambiando el atributo size.
Le pondremos por ejemplo el valor 127.

Esto no significa que la línea de texto que vamos a ingresar esté limitada en 127 caracteres,
sino que lo que veremos a un tiempo en el casillero serán 127 caracteres.
Pero podemos ingresar líneas de texto de tamaño arbitrario.


             <input id='inputscanf' type="text" value="" size=127 />




Nos agradaría también que el eco de un inputscanf quede separado del texto que viene a continuación.
Esto se arregla fácilmente, cambiando la llamada post(str + ' ') anterior por esta otra: post(str + '<br />').
De ese modo, enviamos un salto de línea mediante el tag <br />.

¿Y no podríamos también dejar estos "ecos" más prolijos, agregando un salto de línea previo, o varios?

Como poder, se puede.
Pero dado que nos interesa imitar la consola estándar de Windows, vemos que esto no es necesario.
Incluso a veces tenemos situaciones como ésta:

Introduzca su año de nacimiento: 1977

En azul hemos marcado un mensaje publicado mediante printf, y con marrón el eco de los datos introducidos por el usuario mediante scanf.
Quisiéramos dejar abierta la posibilidad a que el programador pueda decidir colocar ambas informaciones en una misma línea en la browcon.



Por otra parte, ya es hora de que nos saquemos de encima el mensaje que dice: "

(Bloque para muestreo de datos con browcon_printf()...)"
.

Eso lo quitaremos del bloque divprintf, y punto.

Como resultado de esto, el bloque divprintf estará ahora inicialmente vacío.
Y sólo se irá rellenando a medida que le agreguemos texto al atributo innerHTML en sucesivas llamadas a post().



Por último, nos gustaría que visualmente se distingan un poco las publicaciones "normales" de aquellas producidas como el eco de la consola de entrada.

Pondremos en negritas y en color azul a los ecos.
Por ahora aceptaremos este formato, y más adelante veremos maneras de configurarlo a nuestro gusto.

Para lograrlo, hay que agregar el formato HTML mediante un tag span, con atributo color:DarkBlue, por ejemplo, y poniendo también un tag b, para activar las negritas.
Dentro de ese tag span ha de encerrarse el texto, pasado previamente en el parámetro str. La sentencia que logra el cometido es ésta:


                post('<span style="color:DarkBlue"><b>' + str + '</b></span>' + '<br />');


Hemos cambiado muchas veces esa línea, y por un largo rato la dejaremos así.
Pero podremos cambiarla en futuras versiones, para darnos gustos mayores.



Ya está.
Ahora podemos disfrutar de la versión 0.21 de browcon.
A continuación, el código y una foto:

Nombre de archivo: browcon00.21.html

Contenido:

(browcon00.21.html)

<!DOCTYPE HTML>
<!--
      BrowCon
      Version: 00.21
-->

<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('<span style="color:DarkBlue"><b>' + str + '</b></span>' + '<br />');
                document.getElementById('inputscanf').value = '';
           }
     
           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="document.getElementById('inputscanf').value = ''; show_divscanf = true;" />
             
        </div>
        <br />
        <div id="divprintf">

        </div>
        <br />
        <div id="divscanf" style="visibility:hidden">
          <form id='formscanf' action='javascript:senddata(document.getElementById("inputscanf").value);'>   
             <input id='inputscanf' type="text" value="" size=127 />
          </form>
        </div>
     
     </body>

</html>


[cerrar]



En la imagen se ve que, aunque en la consola de entrada puse "Ingresando datos 1977", el casillero de texto quedó de inmediato en blanco tras aparecer el eco en pantalla.
También se aprecia que el eco resalta en azul y en negrita.


11 Mayo, 2013, 04:17 am
Respuesta #6

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
(00.22) Agregando un botón de información

Ciertamente que queda incómoda estar colgándole sentencias JavaScript al atributo onclick del botón "Get data...".

Para evitar esa desprolijidad, haremos allí una llamada a una sola función que llamaremos prepare_input(),
que se encargará de hacer los preparativos para que el usuario pueda entrar datos con el teclado.
Por ahora, esa función tendrá las únicas dos acciones que hasta ahora se activan clickeando el botón.

El botón ahora quedará definido así:


            <input type="button" value="Get data from divscanf" onclick="prepare_input();" />


Y la función prepare_input() dirá esto:


           function prepare_input() {
                document.getElementById('inputscanf').value = '';
                show_divscanf = true;           
           }


Así que, el funcionamiento será el mismo que antes, aunque con más protocolo de por medio.



Aprovechamos este momento de relax para agregar algún adorno a la browcon.
Le pondremos un botón extra en el bloque divcontrol, que muestre información de la versión actual de la browcon.

Para ello, definiremos una función showinfo(), que simplemente publicará en la consola de salida la información en cuestión.
Esta función será llamada al hacer click sobre el nuevo botón "Info".

Le pondremos un color marrón al texto, y también unos adecuados separadores en forma de línea horizontal,
que en HTML se generan con el tag hr.

El botón será éste:


             <input type="button" value="Info" onclick="show_info();" />


La función show_info() será así:


          function show_info() {
              var message = 
                 "<hr />"
                 + "<span style='color:brown'>"
                 + "<b>BrowCon</b><br />"
                 + "Version: " + version + "<br />"
                 + "Date: " + version_date + "<br />"
                 + "</span>"
                 + "<hr />";                                                                             
             
              post(message);
           }


He hecho uso de dos variables globales, con la intención de que esa información pueda modificarse fácilmente en futuras versiones, al principio del tag script.


           version = "00.22";
           version_date = "2013/May/10";




Pongo directamente el enlace a la descarga del archivo con la nueva versión modificada, y abajo una foto que tomé luego de clickear compulsivamente el botón "Info" varias veces:

browcon00.22.html


11 Mayo, 2013, 02:28 pm
Respuesta #7

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
(00.23) Haciendo scroll

Si experimentamos con la versión 00.22, veremos que las publicaciones se van acumulando por debajo, pero que seguimos viendo siempre las primeras, y sólo podemos ver los datos más "actualizados" sólo si manualmente hacemos scroll con la barra del lado derecho del navegador.

Queremos que nuestra browcon no sólo vaya mostrando los datos que le enviemos, sino que lo primero que veamos en pantalla sea lo último que enviamos.
También queremos tener acceso (en forma manual) a todo lo que se haya enviado previamente a la browcon.
Para ello, agregaremos al bloque divprintf una barra de scroll vertical, delimitaremos su espacio a unos 400 pixeles de alto en pantalla, y finalmente, al agregar nueva información, daremos la orden de que se produzca un scroll automático hasta la parte más inferior del bloque, empujando hacia arriba la información más antigua.

La consola de salida quedará ahora así:


        <div id="divprintf" style="height:400px; overflow-y:scroll">

        </div>


Los 400 píxeles de alto se han seleccionado, como claramente se ve, mediante el atributo style, y el subatributo height.
La barra de scroll vertical se ha colocado mediante el subatributo overflow-y, seleccionando la opción scroll.

Como uno puede inferir, el subatributo overflow-y se refiere a la acción que debe tomar el navegador cuando el bloque div debe mostrar más contenido que el le cabe normalmente por su tamaño.
Hemos seleccionado que esto se controle mediante una barra de scroll vertical bien visible.

Ahora bien, cada vez que invocamos la función post(), quisiéramos que el contenido antiguo sea empujado hacia arriba. Para esto, hay que modificar el atributo scrollTop del bloque divprintf, haciendo que tome el valor del atributo scrollHeight.
Con esto logramos que el tope superior del bloque se sitúe en la posición que coincide con la última línea, que, oh casualidad, es el valor de la altura total que actualmente tiene el bloque (contando toda la información contenida en él).

La funciòn post() se redefine, entonces, de la siguiente manera:


           function post(str) {
                document.getElementById('divprintf').innerHTML += str;
               
                var x = document.getElementById("divprintf");
                x.scrollTop = x.scrollHeight;
           }





Un detalle que me gustaría modificar en este mismo cambio de versión,
es la falta de "foco" cuando se hace visible la consola de entrada divscanf.
Creo que sería apropiado no sólo que se haga visible, sino que al mismo tiempo el cursor aparezca automáticamente allí, listo para que el usuario ingrese datos, y no como hasta ahora, que hay que ir hasta el casillero con el puntero del ratón y clickear allí para activarlo.

Para corregir este defecto, es necesario modificar el atributo de "foco" en la función Refresh_Console(),
justo después de la sentencia que hace visible la consola de entrada.
Agregamos la sentencia siguiente:


                   document.getElementById('inputscanf').focus();


La función luce ahora así:


           function RefreshBrowser() {   
             
              if (signal_divprintf) {
                   signal_divprintf = false;
                   post('Test divprintf. --- ');
              };
             
              if (show_divscanf) {                   
                   document.getElementById('divscanf').style.visibility = "visible";
                   document.getElementById('inputscanf').focus();
              } else {
                   document.getElementById('divscanf').style.visibility = "hidden";
              }
     
           }


Con esto, el cursor se posicionará ahora automáticamente en cada evento de entrada de datos.



Quitaré la información de la versión de los comentarios iniciales, y la pondré toda en la función show_info().
De ese modo no tendré luego que cambiar esta información en varios lugares distintos del documento.

Pero también me gustaría que dicha información sea lo primero que resalte al abrir el documento con un editor de texto, o un depurador.
Así que añadí una nueva sección script en la sección head del documento.
En esa sección pondré la función show_info() y las variables que informan de la versión de la browcon.



Archivo para descargar, y foto:

browcon00.23.html


11 Mayo, 2013, 05:08 pm
Respuesta #8

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
(00.24) Fabulosos riesgos de seguridad

El modo en que estamos programando nuestra consola de entrada es muy riesgoso.
Básicamente, permite que el usuario tenga control del navegador, y puede llegar a hacer todo tipo de estragos.

Abrir el documento browcon00.23.html con Internet Explorer, y clickear en "Get data...".

En el casillero de entrada de datos, pegar el siguiente texto:

<form onmouseover="window.open('http://rinconmatematico.com','popUpWindow')">Te abro la página que yo quiero, jejejeje</form>

Al enviar el texto con Enter, se creará en nuestro documento un formulario con el texto "Te abro la página que quiero, jejejeje".
Y peor aún, moviendo el puntero del ratón sobre dicho texto, se nos abrirá una ventana del navegador con la web del rincón.

Esto puede hacerse con cualquier web, y prácticamente cualquier cosa.

He intentado ejecutar programas de Windows poniendo los comandos javascript adecuados, y aunque ActiveX lo permite, parece que hay restricciones de seguridad del propio Internet Explorer que lo impiden.
Pero creo que puedo burlar esas restricciones de seguridad...

Entonces aquí hay un agujero grave de seguridad, que tendremos que remediar.

En general, no es admisible que el usuario haga reaccionar un documento HTML, haciendo que lo convierta en un festín de acciones impredecibles y pintorescas.
(Pueden abrirse imágenes, cambiar formatos, enlazar a otras webs, ejecutar aplicaciones del sistema, etc.)



Para "remediar" esta simpática situación, vamos a desactivar  :'( todo tipo de reacciones en el texto ingresado por el usuario.

Esto se logrará reemplazando los caracteres "reactivos" en HTML (< > &) por sus códigos equivalentes "no reactivos": &lt; &gt; &amp;.
Definimos una función javascript llamada prevent_html(), que toma un parámetro str (una cadena de texto), y la transforma en una cadena "no reactiva", mediante el método replace().

Lo primero que se debe eliminar son los signos &, ya que en sucesivos reemplazos hay riesgo de mezclar apariciones originales de & con las que estamos introduciendo nosotros.  :o


           function prevent_html(str) {
               return str.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;");
           }


Ahora usamos esa función cuando se llama a post() dentro de senddata():


         post('<span style="color:DarkBlue"><b>' + prevent_html(str) + '</b></span>' + '<br />');


Y listo, solucionado el problema.

Ahora adjuntamos la nueva versión, y mostramos una foto con el ejemplo que teníamos al principio (en que el usuario intenta entrar como cadena de texto el código que genera un formulario que a su vez abre casi automáticamente una página web).
Pero ahora se ha "neutralizado" todo intento dañino del usuario mediante la función prevent_html().

browcon00.24.html



 

11 Mayo, 2013, 09:09 pm
Respuesta #9

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
(00.25) Reducción de autocolisiones

Dado que nuestra browcon funciona mediante "refrescos" (o mejor dicho, "rellamadas") a la función RefreshConsole() cada 3 segundos, y dado que esto abre la posibilidad a que varias instancias de esta función se vayan superponiendo, causando resultados inesperados e indeseables, me parece oportuno lidiar con esto ahora mismo, investigando el modo de solucionarlo.

Vamos a realizar varios tests para ver qué es lo que ocurre.
Esto implica agregar a nuestra browcon unas acciones superfluas, que no estarán presentes en la versión definitiva, pero que necesitamos ahora a fin de depurar el proyecto.

En primer lugar, vamos a definir una variable global que haga el recuento de cuántas instancias de la función RefreshConsole() se están ejecutando al mismo tiempo.
La llamaremos RCinst, y su valor inicial será, por supuesto, 0.

Cada vez que llamemos a RefreshConsole(), cada 3 religiosos segundos, según el cronómetro fijado al principio con setInterval(), haremos que se incremente en 1 el valor de RCinst, que entonces será un contador de instancias de RefreshConsole() activas.
A fin de que este contador muestre información fiable, tendrá que decrecer en 1 al finalizar todas las acciones en una llamada de RefreshConsole().

Además, mostraremos directamente el valor de la variable RCinst en la consola de salida, y por eso pondremos una llamada a post() informando ese valor.


           RCinst = 0;


           function RefreshBrowser() {   
             
              RCinst += 1;
              post('RCinst: '+RCinst.toString() + '<br />');
             
              // Aquí va el código que estaba en la versión 00.24...
             
              RCinst -= 1;
     
           }


Ahora bien.
Dado que las repeticiones se producen cada 3 segundos, es improbable que haya llamadas superpuestas a RefreshConsole().

Para que este fenómeno se ponga en evidencia, hay que reducir el tiempo entre repeticiones.

Hice la reducción a 1 milisegundo, y aún no hay colisiones visibles.
Así que las posibles autocolisiones de llamadas a RefreshConsole(), puede que se trate de un fenómeno esquivo.
Pero aún así lo tendré en cuenta.

Lo que voy a hacer acá es verificar si ya ha habido una llamada previa a RefreshConsole(),
y sólo si no hay instancias previas ejecutándose, ejecutaremos las sentencias que siguen en la función.

Entonces cambiaré las líneas anteriores, verificando solamente si hay o no una llamada a RefreshConsole() que está activa.
Reescribo la función así:


           RCactive = false;

           function RefreshBrowser() {   
             
                if (!RCactive) {
             
                        RCactive = true;
             
                        // Sentencias que estaban desde antes...               
                       
                        RCactive = false;
             
                 }
             
     
           }


Ahora bien.
No me parece que esto sea suficiente.

Hay dos maneras de interrumpir la paz de la browcon.
Una es con órdenes tipo printf (salida) y otra es con órdenes tipo scanf (entrada).

En cualquiera de los dos casos, que se activan de forma bastante independiente, queremos que RefreshConsole() no haga nada mientras esas tareas no han sido debidamente terminadas.

Agreguemos entonces otra variable más, llamada InputActive, que será true mientras el casillero de texto de divscanf está activo, y false en caso contrario.
Su valor inicial es false.

Se pone a true cuando se detecta una petición a la consola de entrada, y esto se efectuaría en la función prepare_input().

Debido a que nos interesa evitar las posibles autocolisiones tanto como sea posible,
no tenemos ningún apuro en poner InputActive a true.
Así, es una acción "demorada".
Por lo tanto, se coloca al final después de haber culminado las acciones de la función prepare_input(),
y más aún, después de haber puesto el foco (o el cursor) en el bloque divscanf.
Esto ha de ser así si queremos que se ejecute al menos 1 vez el bloque "if" asociado a la consola de entrada en RefreshConsole().

Finalmente, al final de las acciones en senddata() debe ponerse InputActive a false, indicando que ya no es necesario esperar a que el usuario introduzca datos en la consola de entrada.

Con este último cambio buscamos que no vuelva persistentemente el "foco" sobre la consola de entrada, y así, por ejemplo, podemos mover el ratón libremente por la página o fuera de ella, y así por ejemplo copiar y pegar porciones de texto en la consola de entrada en forma cómoda.

Al mismo tiempo, no se permite que la browcon acepte o emita datos mientras el casillero de texto esté visible.



Además, como ya me está empezando a cansar la lenta actualizaciòn cada 3 segundos, he cambiado a 500 milisegundos (0.5 segundos) la frecuencia del ciclo de "refresco".



Los cambios importantes se exhiben a continuación:


     <body onload="setInterval('RefreshBrowser()', 500);">
        <script type="text/javascript">
         
           RCactive = false; // RefreshConsole()'s is active or not 
           InputActive = false;     

          function senddata(str) {
                                         
                show_divscanf = false; 
                post('<span style="color:DarkBlue"><b>' + prevent_html(str) + '</b></span>' + '<br />');
                document.getElementById('inputscanf').value = '';

                InputActive = false;
           }
     
           function RefreshBrowser() {   
             
             if (!RCactive && !InputActive) {
             
                        RCactive = true;
             
                        if (signal_divprintf) {
                            signal_divprintf = false;
                            post('Test divprintf. --- ');
                        };
                       
                        if (show_divscanf) {                   
                            document.getElementById('divscanf').style.visibility = "visible";
                            document.getElementById('inputscanf').focus();
                 
                            InputActive = true;
                        } else {
                            document.getElementById('divscanf').style.visibility = "hidden";
                        }                 
                       
                        RCactive = false;
             
              }
           }
 


Archivo adjunto:

browcon00.25.html