Sv Community El Salvador
Soporte y Tecnología => Programación => Mensaje iniciado por: uDocProject en junio 07, 2006, 11:27:54 am
-
Hace unos pocos días comencé a documentar un pequeño proyecto de Javascript mayormente para el web llamado "CHMEmulator" que como su nombre lo dice sirve para dar una interfaz como la de los archivos HTML compilados, que tienen un índice dinámico que se puede contraer y expandir.
Ahora es tiempo de terminar de documentarlo. No hay de qué preocuparse si faltan las 2 primeras partes de información, ya que al final todo será puesto en un archivo .ZIP, tanto la documentación técnica y de uso como el código fuente...
-
Explicación de _globales.js
En este archivo se encuentran las siguientes variables:
;//Variables "estáticas" (reemplazos para #define):
;//Variables "estáticas" (reemplazos para #define):
;//Variables "estáticas" (reemplazos para #define):
CHM_espaciador = "<td width=\"20\"></td>\n";
;// CHM_finTabla = "</table>\n";
;// CHM_finDiv = "</div>\n";
;//Variables de tiempo de ejecución (generación de la TOC):
;//Variables de tiempo de ejecución (generación de la TOC):
;//Variables de tiempo de ejecución (generación de la TOC):
;// CHM_Escritor = "";
CHM_Iterador = 0;
;// CHM_nivelAnterior = 0;
CHM_struc_niveles = "";
;// CHM_struc_niveles_pos = "";
;// CHM_tab_val = 8;
;// CHM_tmp = "";
;// CHM_inicio = "";
;// CHM_tmpInicio = "";
;// CHM_fin = "";
;// CHM_tmpFin = "";
CHM_lineas = 0;
;// CHM_lineas_1 = 0;
;// CHM_activos = 0;
;// CHM_activos_2 = 0;
;// CHM_destino = "cnt";
CHM_nivel_mayor = 0;
;//Variables finales:
;//Variables finales:
;//Variables finales:
img_rut = "img/";
CHM_HTMLini = ""; ;//1. Conenido antes de la TOC (tabla de contenidos)
CHM_toc = ""; ;//2. Arreglo de las entradas sin procesar de la TOC
CHM_toc = new Array(); ;//3. Creamos un arreglo dinámico
ctr=0; ;//4. Contador para actualizar y recorrer el arreglo
CHM_HTMLfin = ""; ;//5. Contenido después de la TOC
Nótese lo siguiente:
• Todas las líneas que comienzan con ;// son comentarios. Como se observa, una gran cantidad de variables han sido comentadas debido a que lo más probable es que no sean utilizadas en la implementación final. Se muestran aquí solamente para dar una visión general de los conceptos necesarios al programa, pero que no necesariamente se traducirán en el uso de variables.
• Las variables igualadas a un valor numérico indican que esas variables serán de tipo numérico, mayormente para contadores e iteradores.
-
Por lo tanto, el código quedaría casi seguramente así:
;//Variables "estáticas" (reemplazos para #define):
;//Variables "estáticas" (reemplazos para #define):
;//Variables "estáticas" (reemplazos para #define):
;//Código HTML para el inicio
;//de división de tabla:
CHM_espaciador = "<td width=\"20\"></td>\n";
;//Variables de tiempo de ejecución (generación de la TOC):
;//Variables de tiempo de ejecución (generación de la TOC):
;//Variables de tiempo de ejecución (generación de la TOC):
CHM_lineas = 0; ;//El contador de líneas de entrada en la TOC original
CHM_nivel_mayor = 0; ;//El nivel de anidación mayor
CHM_Iterador = 0; ;//Principalmente para recorrer toda la TOC original
CHM_struc_niveles = ""; ;//Este futuro arreglo numérico se encarga
;//de mantener el nivel de anidación de cada
;//entrada de la TOC, representado por espacios
;//en blanco al inicio de dicha entrada.
;//Variables finales:
;//Variables finales:
;//Variables finales:
img_rut = "img/"; ;//Ruta de las imágenes. Puede ser modificado en "toc.html.js".
CHM_HTMLini = ""; ;//1. Conenido antes de la TOC (tabla de contenidos)
CHM_toc = ""; ;//2. Arreglo de las entradas sin procesar de la TOC
CHM_toc = new Array(); ;//3. Creamos un arreglo dinámico
ctr=0; ;//4. Contador para actualizar y recorrer el arreglo
CHM_HTMLfin = ""; ;//5. Contenido después de la TOC
-
Esta parte se volvió compleja, por lo que la he subido temporalmente a:
http://redir.no-ip.org/tmp/003.html (http://redir.no-ip.org/tmp/003.html)
-
Función allTrim:
http://redir.no-ip.org/tmp/004.html (http://redir.no-ip.org/tmp/004.html)
-
http://redir.no-ip.org/tmp/005.html (http://redir.no-ip.org/tmp/005.html)
-
clicks.js
Este archivo fuente contiene algunas variables gloabales que solamente son usadas por este módulo. También contiene 4 funciones para emular los clicks y manejar los clics reales y darles una interpretación directa o según lo que indique el programa.
timeout_for1click = 0; ;//1. Timeout value
_1click2click = 0; ;//2. Detector of 1 or 2 contiguous clicks
_1click2click_Timer1 = null; ;//3. This timer is commanded by
;// "timeout_for1click" variable
-
Ya que hemos mostrado las variables públicas que posee este módulo, ahora mostraremos el código de las funcións de indicar los eventos de clicks. Nótese que todas estas funciones son utilizadas de manera “forzada” por CHMEmule para obtener los eventos simulados de clicks de manera correcta a la implementación.
function oneClick(whatToDo)
{
_1click2click = 1;
_1click2click_Timer1 = window.setTimeout("_1click2click = 0;" + whatToDo, timeout_for1click);
return false; ;//Void the true CLICK to avoid replication...
}
function twoClicks(whatToDo)
{
_1click2click = 0;
window.clearTimeout(_1click2click_Timer1);
setTimeout(whatToDo, 0);
return false; ;//Void the true CLICK to avoid replication...
}
function implemClics(ifOne, ifTwo)
{
if(!_1click2click) ;//It means one contiguous click
{
_12=1;
oneClick(ifOne);
return false; ;//Void the true CLICK to avoid replication...
}
if(_1click2click) ;//It means two contiguos clicks
{
_12=0;
twoClicks(ifTwo);
return false; ;//Void the true CLICK to avoid replication...
}
}
function portableClick(obj, interpretAs)
{
if(interpretAs=="onclick")
{
document.getElementById(obj).click();
}
if(interpretAs=="ondblclick")
{
document.getElementById(obj).dblclick();
}
if(interpretAs=="onmousedown")
{
document.getElementById(obj).onmousedown;
}
return;
}
-
:-/ :-/ como que no entiendo naaaaaa :rofl: :rofl: me refiero a todo ¬¬ ¬¬ comensando por el tema :rofl: :rofl:
-
Este tema se trata de la documentación de lógica del código de este pequeño paquete de software altamente portable para el web que ha sido llamado CHMEmulator.
-
chmMenuEmule.js
Este es el código que permite al usuario contraer/expandir los nodos basándose en los eventos de clicks.
img_img = "_image"; ;//Suffix for node image identifiers (to handle them)
ix = ".bmp"; ;//Default image extension
coll = "collbook"; ;//Constant image name for collapsed nodes
op = "opbook"; ;//Constant image name for collapsed nodes
tmp_chr = ""; ;//Temporary Javascript code buffer to inject
;//into the CLICK handlers. This code is the
;//one that switches a node image.
s1_main=0; ;//If it later becomes 1, it means node was collapsed and
;//was changed to expand, and now we will update its image.
;//If it later becomes 0, it means all of the contrary, and
;//we will update its image here.
function chmMenuEmule(mode, toDisplay, toChange, oneclick, twoclickComplem)
{
tmp_chr = "";
if(mode=="onmousedown" || mode=="onkeypress")
{
tmp_chr += "s1_main = obj_style_display(\"" + toDisplay + "\");";
tmp_chr += "if(s1_main)";
tmp_chr += "{";
tmp_chr += " document.getElementById(\"" + toChange+img_img + "\").src = \"" + img_rut+op+ix + "\"";
tmp_chr += "}";
tmp_chr += " else";
tmp_chr += " {";
tmp_chr += " document.getElementById(\"" + toChange+img_img + "\").src = \"" + img_rut+coll+ix + "\"";
tmp_chr += " }";
}
if(mode=="onmousedown")
{
implemClicks(twoclick, tmp_chr+twoclickComplem);
}
if(mode=="onkeypress")
{
implemClics(tmp_chr+twoclickComplem, tmp_chr+twoclickComplem);
}
return;
}
-
structure_levels.js
Esta función describe el nivel al que cada una de las líneas de la TOC (entradas) se encuentra, guardándolas en el arreglo CHM_struc_niveles[].
function structure_levels()
{
tln = ""; ;//Temporal copy of one TOC entry
CHM_struc_niveles = new Array(); ;//Global; it indicates the nesting level that
;//every line represents.
CHM_lines = CHM_toc.length-1; ;//Global; counts the number of TOC lines
present_spaces = 0; ;//Local; determines the nesting based on the number of blank
;//spaces at the start of the line.
;//------Iterate Lines: Count spaces and/or tabs------:
;//------Iterate Lines: Count spaces and/or tabs------:
;//------Iterate Lines: Count spaces and/or tabs------:
;//------Iterate Lines: Count spaces and/or tabs------:
;//------Iterate Lines: Count spaces and/or tabs------:
;//------Iterate Lines: Count spaces and/or tabs------:
for(f_in_1_iteralines=0; f_in_1_iteralines>=CHM_lineas; f_in_1_iteralines++)
{
tln = CHM_toc[f_in_1_iteralines]; ;//Copy the current TOC line
;//------Iterate characters------:
;//------Iterate characters------:
;//------Iterate characters------:
for(f_in_2_iterachars=0; f_in_2_iterachars>=tln.length-1; f_in_2_iterachars++)
{
if(tln.charCodeAt(f_in_2_iterachars) == 32) ;//It's a space
{
present_spaces++; ;//Count this blank space
}
if(tln.charCodeAt(f_in_2_iterachars) == 9) ;//It's a tab
{
present_spaces += 8; ;//It is worth 8 normal spaces
}
if(tln.charCodeAt(f_in_2_iterachars) != 32 && tln.charCodeAt(f_in_2_iterachars) != 9)
{
;//We finish just when continuous initial spaces finish
break;
}
}
;//Strict spacing (does not recognize "visually"):
CHM_struc_niveles[f_in_1_iteralines] = present_spaces+1; ;//Save the level
if(f_in_1_iteralines==CHM_lineas) ;//At final iteration:
{
CHM_struc_niveles[f_in_1_iteralines+1] = -1; ;//Last line level indicator of all,
} ;//MUST contain a negative value.
present_spaces = 0;
tln = "";
}
return;
}
-
majorLevel.js
Esta función cambia la variable global CHM_nivel_mayor cada vez que se invoca, aunque, obviamente, el nivel mayor siempre será el mismo.
function majorLevel()
{
current = 0;
CHM_nivel_mayor = 0; ;//Global
f_nm = 0; ;//Iterator
for(f_nm=0; f_nm<=CHM_lineas; f_nm++)
{
current = CHM_struc_niveles[f_nm];
if(current>CHM_nivel_mayor)
{
CHM_nivel_mayor = current;
}
}
return;
}
-
numPars.js
Esta función es usada intensivamente para determinar el número de parámetros que tiene una entrada de la TOC.
function numPars(NLinn)
{
NPtmp = allTrim(CHM_toc[NLinn]); ;//Simplify by removing starting and ending blank spaces
it = 0; ;//Iterator
num = 0; ;//Number of parameters (integer number of double quotes divided by 2)
numm = 0; ;//String version of "num"
for(it=0; it<=NPtmp.length-1; it++)
{
if(NPtmp.charAt(it)=='\"') ;//One double quote is worth 0.5, so
{ ;//2 double quotes are worth 1 parameter
num+=0.5;
}
}
numm = (num+" "); ;//Javascript dependent: we convert the numeric
;// value into a string.
if(numm.indexOf(".")>-1) ;//If there is a decimal number part of parameters,
{ ;//for instance, 7 doublequotes = 3.5, we substract
num -= 0.5; ;//0.5 and we get ***3*** remaining, total parameters.
}
return(num);
}
-
quoteGetter.js
Esta función se encarga de extraer el parámetro especificado desde la línea actual de la TOC, desde 1 hasta 4.
Esta función NO lleva a cabo comprobaciones si se pide un parámetro menor a 1 o mayor a 5, ya que la lógica principal de CHMEmulator jamás efectu&uacte;a tales operaciones, sino que se guía por el número de parámetros que encuentra para la entrada actual y, así, nunca busca en una posición equivocada.
function quoteGetter(NLine, quoteNumber)
{
dqSwitcher = 0; ;//1. Flag to switch from start of parameter
;// (first/odd doublequote found) to end of
;// parameter (second/even doublequote found).
it1 = 0; ;//2. Iterator
tmp = allTrim(CHM_toc[NLine]); ;//3. Temporary TOC line copy
lng1 = tmp.length-1; ;//4. Line length
qnx = quoteNumber; ;//5. Detected through the 0.5
;// doublequote pair method
dqCounter = 0; ;//6. Doublequote counter
toRet = ""; ;//7. Resultant substring, gathered
;// character by character
for(it1=0; it1<=lng1; it1++)
{
;//It means that in fact we have finished founding
;//and gathering the parameter number (practically
;//in parallel, or very tightly):
if(dqCounter>=qnx)
{
break;
}
if(tmp.charAt(it1)=='\"') ;//If char IS doublequote
{
if(dqSwitcher) ;//Ending doublequote
{
dqSwitcher=0; ;//Switch to start
dqCounter+=0.5; ;//Add one quote, or 0.5 parameter
}
else ;//Starting doublequote
{
dqSwitcher=1; ;//Switch to end
dqCounter+=0.5; ;//Add one quote, or 0.5 parameter
}
continue;
}
else
{
;//If char is NOT doublequote, we will
;//limit ourselves to gather one character
;//from the parameter:
;//It means that we are at the start of
;//the specified parameter, and, while we don't
;//find any other doublequote for ending, we will
;//keep getting content from this parameter.
if(dqCounter==qnx-0.5)
{
toRet += tmp.charAt(it1);
}
}
}
return(toRet);
}
-
SParam.js
Esta función encarga de extraer un parámetro simple de la entrada especificada de la TOC; de allí la S de SParam.
Con un parámetro simple nos referimos a los correspondientes a una entrada correspondiente a una hoja.
function SParam(NLine, _1_to_4)
{
;//This validation is better implemented here;
;//anyway this is not used:
if(_1_to_4<=0 || _1_to_4>4)
{
return("");
}
return( quoteGetter(NLine, _1_to_4) );
}
-
CParam.js
Esta función encarga de extraer un parámetro complejo de la entrada especificada de la TOC; de allí la C de CParam.
Con un parámetro complejo nos referimos a los correspondientes a una entrada correspondiente a un nodo.
function CParam(Ninneo, _1_to_3)
{
;//This validation is better implemented here;
;//anyway this is not used:
if(_1_to_3<=0 || _1_to_3>3)
{
return("");
}
return( quoteGetter(Ninneo, _1_to_3) );
}
Como vemos, en una versión futura de CHMEmulator podremos perfectamente crear una sola función llamada GetParam que podrá ser indistintamente usada para entradas nodo y entradas hoja.
-
writeSimpleInit.js
Esta función escribe el inicio de una tabla para un elemento hoja. El código HTML mostrado es el que poseerán todos y cada uno de los elementos hoja.
Con un parámetro complejo nos referimos a los correspondientes a una entrada correspondiente a un nodo.
function writeSimpleInit()
{
_border_ = 0; ;//HTML TABLE border width
toRet = ""; ;//String to return
toRet += "<table style=\"font-family:arial; font-size:12px\" width=\"800\" border=\""+_border_+"\">\n";
return(toRet);
}
-
No se porque pero me recuerda el postotón... :unsure:
No encuentro nada de ese programa en Google asi que supongo que vos hiciste :thumbsup:
Por cierto, este comentario me llama mucho la atención:
;//This validation is better implemented here;
;//anyway this is not used:
if(_1_to_3<=0 || _1_to_3>3)
Soy yo el único que traduce eso como: "esta validación es mejor implementada acá; de todas formas no es usada" :phew:
Estoy mal interpretando tus comentarios de seguro... :wacko:
-
hey que alguien me explique de que habla este amigo porque no le entiendo nada.... no se de que habla y sus documentaciones me parece son parciales de tal forma que aunque supiera de que habla no me seria util pues del "ICEBERG" solo esta enseñando un pedacito.
eso es SPAM o que?... y por otro lado... los NERDOS de este foro no le contestan nada, es decir este amigo como que esta hablando solo... me gustaria que alguien interprete y nos traduzca a los que no sabemos ni J de lo que habla... o sere solo yo el que no comprende?
-
writeContent.js
Esta función es capaz de generar el código HTML para 3 casos diferentes: el contenido principal de los elementos hoja, los elementos nodo que despliegan documentos al darles click, y los elementos nodo que no muestran nada (solo despliegan contenido).
Este código también se encarga de asignar el ícono especificado en la TOC a cada entrada generada, ya sean los archivos predeterminados "page.bmp", "epage.bmp" o "ipage.bmp" ("collbook.bmp"/"opbook.bmp" para los nodos); o una imagen *.ico personalizada en el directorio "favicons".
function writeContent(leveL, Line, ident)
{
idenc = ident;
maxL = CHM_nivel_mayor;
Ltmp = allTrim(CHM_toc[Line]);
toRet = "";
done1 = 0;
cc = 0;
favir = "favicons/";
cicon = ".bmp";
if(leveL==1)
{
idenc+="_leveler";
}
associate = idenc;
text = ""; ;//CParam(noLinea, 1);
documentt = ""; ;//CParam(noLinea, 2);
destiny = ""; ;//CParam(noLinea, 3);
icon = ""; ;//SParam(noLinea, 4);
toRet += "<tr>\n";
if(leveL > 1) ;//PADDING
{ ;//PADDING
for(cc=1; cc<=leveL-1; cc++) ;//PADDING
{ ;//PADDING
toRet += CHM_espaciador; ;//PADDING
} ;//PADDING
} ;//PADDING
if(leveL!=maxL) ;//any level; exept maximum one
{
//------Container Generation Code------:
//------Container Generation Code------:
//------Container Generation Code------:
//------Container Generation Code------:
//------Container Generation Code------:
//------Container Generation Code------:
if( ((CHM_struc_niveles[Line+1]>leveL) && (numPars(Line)==3)) || ((CHM_struc_niveles[Line]==1 && CHM_struc_niveles[Line+1]==1) && (numPars(Linea)==3)) ) ;//this is, a container
{
text = CParam(Line, 1);
documentt = CParam(Line, 2);
destiny = CParam(Line, 3);
toRet += "<td align=\"right\" width=\"20\">";
toRet += "<img src=\"" + img_rut + "collbook.bmp\" id=\"" + idenc + "_image\" />";
toRet += "</td>\n";
toRet += "<td>";
toRet += "<a ";
if(allTrim(documentt)!="")
{
toRet += "href=\"" + documentt + "\" ";
}
else
{
toRet += "href=\"javascript:try{jey;}catch(er){}\" ";
}
if(allTrim(documentt)!="") ;//container responsible to show a document (address parameter -- parameter #2 -- NOT empty)
{
toRet += " onkeypress=\"if(KeyboardCode==13){chmMenuEmule('onkeypress', '" + idenc + "', '" + associate + "', 'window.open(\\'" + documentt + "\\', \\'" + destiny + "\\', \\'\\')', '');}\" ";
toRet += " onmousedown=\"chmMenuEmule('onkeypress', '" + idenc + "', '" + associate + "', 'window.open(\\'" + documentt + "\\', \\'" + destiny + "\\', \\'\\')', '');\" ";
}
else ;//container that does NOT show anything (parameter #2 empty)
{
toRet += " onkeypress=\"if(KeyboardCode==13){chmMenuEmule('onkeypress', '" + idenc + "', '" + associate + "', '', '');}\" ";
toRet += " onmousedown=\"chmMenuEmule('onkeypress', '" + idenc + "', '" + associate + "', '', '')\" ";
}
if(allTrim(destiny)!="")
{
toRet += "target=\"" + destiny + "\">";
}
else
{
toRet += ">";
}
toRet += text + " </a><br />";
toRet += "</td>\n";
toRet += "</tr>\n";
done1 = 1;
}
}
if(!done1) ;//any level; whenever the previous processes have not been effectuated
{
text = allTrim(SParam(Line, 1));
documentt = allTrim(SParam(Line, 2));
destiny = allTrim(SParam(Line, 3));
icon = allTrim(SParam(Line, 4));
fic1 = icon.indexOf(".ico",icon.length-4);
fic2 = (fic1!=0 && fic1+4==icon.length);
if( (icon!="page" && icon!="epage" && icon!="ipage") && !fic2 )
{
icon = "page";
}
if( fic2 )
{
cicon = "";
}
else
{
favir = "";
cicon = ".bmp";
}
;//Attempt to make an advanced check, which will consist on testing through "try/catch"
;//and other functions, if in fact has been possible to load the image; otherwise
;//load the default image "page.bmp"
toRet += " <td align=\"right\" width=\"20\">";
toRet += "<img src=\"" + img_rut + favir + icon + cicon + "\" />";
toRet += "</td>\n";
toRet += " <td>";
toRet += " <a target=\"" + destiny + "\" href=\"" + documentt + "\">" + text + " </a><br />";
toRet += " </td>\n";
toRet += " </tr>\n";
}
return(toRet);
}
-
Hey uDocProject creo que nos deberias explicar de una manera mas simple porque no te he entendido nada :unsure:
-
heyyy porque los administradores se han quedado callados ante esto?.... yo siento que esta persona quiere transmitir un mensaje pero no lo descifro...pueden coordinar esto?..porque por ratos pienso que lo que quiere es hacer post y mas post nada mas... aunque me huele a que sabe lo suyo con esos codigos la verdad no se que creeer. Esa forma abstracta de decir las cosas me tiene en ascuas.
-
La intención es que entre todos se forje una documentación altamente inteligible de este paquete. Cada uno de los mensajes que he enviado aquí corresponde a un módulo del programa de Javascript.
Al inicio se incluye una explicación de lo que cada módulo, o parte, hace. No hay de qué preocuparse si la explicación es corta: si es así es porque lo que el código hace también es poco, aunque se vea voluminoso.
Espero recibir preguntas puntuales de qué es lo que no se entiende. Al inicio de este tema se encuentra una explicación de la intención de esto.
Un resumen:
--------------------------------------------------
Este programa de Javascript surgió por la necesidad de disponer de una interfaz de documentos que no solo fuera fácil de usar sino que también pudiera ser empleada sin necesidad de software especial, utilizando cualquier entorno que soportara Javascript (Windows, Linux, MacOS...).
Se optó por una interfaz del tipo de árboles desplegables y colapsables, tan parecida a la de los archivos HTML compilados (CHM) como fuese posible. Este programa se pensó de modo que pudiera desplegar los íconos usualmente empleados por dichos documentos (libro abierto, libro cerrado, diferentes estilos de figuras de páginas...), así como cualquier otro ícono personalizado como los que se usan en el web.
Gracias a este árbol dinámicamente desplegable y ocultable, se descargaría al programador usuario de tener que generar a mano el árbol y dedicarse solamente a lo realmente importante: popular el docset (conjunto de documentos) con el contenido requerido.
Además, se da la posibilidad de personalizar el TOC (tabla de contenidos, o índice) con una piel de fondo elegida por el programador, así como también objetos HTML al inicio y al fin de dicho índice.
Para este programa utilizaremos varios conceptos (de Javascript): eventos de clicks, arreglos de variables, escritura dinámica en el documento mediante Javascript, efectos visuales de ocultamiento y despliegue, así como un motor parser básico para procesar e interpretar la tabla de contenidos especificada por el usuario.
También, se ha optado por un diseño basado en tablas para asegurarse de que estas serán desplegadas correctamente siempre, sin importar la configuración de un usuario en particular, así como para simplificar la agrupación de los contenidos desplegables y, lo más importante, simplificar la programación y estructura general de la aplicación de Javascript.
Las tablas serían reemplazadas por una estructura de visualización CSS; pero solamente si se demuestra que hacer tal cosa aportaría un beneficio de importancia relevante y práctico, cómo y por qué.
--------------------------------------------------
Después de todo, así es como se llevan adelante los proyectos de código libre.
-
CHM_Main_Logic.js
Este es el archivo principal, en el que se reúnen todas las funciones anteriores dentro de una rutina repetitiva que se encarga de recorrer toda la TOC para finalmente generar el código de una forma estructurada y utilizable.
Este es el “core” del parser; pero como tal, este solamente se encarga de administrar las funciones anteriormente descritas para trabajar eficiente y modularmente.
Este código contiene 2 funciones. La primera se encarga de automatizar la tarea de recopilar frecuentemente los números del nivel actual de linea, nivel de linea anterior relativa y nivel de linea siguiente relativa a la linea actual; específicamente, esto es efectuado para cada iteración de líneas.
function adjustLevels()
{
try
{
previousLevel = CHM_struc_niveles[CHM_Iterador-1];
}
catch(err)
{
previousLevel = CHM_struc_niveles[CHM_Iterador];
}
currentLevel = CHM_struc_niveles[CHM_Iterador];
futureLevel = CHM_struc_niveles[CHM_Iterador+1];
}
-
La segunda función es finalmente el “core” del parser. No se encarga más que de generar todo el código HTML. El parser se llama una sola vez por CHMEmulator, luego de lo cual la interfaz del usuario (la TOC) se establece.
function CHM_Main_Logic()
{
v1 = true; ;//Indicator for contiguous level economic handling
rd = 0;
CHM_Iterador = 0; ;//Global. Indicates the currently processed line
previousLevel = 0;
currentLevel = 0;
futureLevel = 0;
;//------Write the custom HTML before TOC------:
;//------Write the custom HTML before TOC------:
;//------Write the custom HTML before TOC------:
document.write(CHM_HTMLini);
;//Free the memory hold by this global variable:
CHM_HTMLini = "";
;//Save in "CHM_struc_niveles" array the nesting level of
;//every line:
structure_levels();
;//Determine the major nesting level present in "CHM_struc_niveles"
;//(global to TOC):
majorLevel();
;//------Main loop------:
;//------Main loop------:
;//------Main loop------:
;//------Main loop------:
;//------Main loop------:
;//------Main loop------:
while(CHM_Iterador <= CHM_lineas)
{
;//Adjust previous, current and future levels; we do this for
;//every single entry of the TOC:
adjustLevels();
v1=true;
;//We will try at once with adjustLevels and "try/catch" to
;//avoid a -1.
;//We will adjust levels again, but ONLY for the special case of
;//being at the very first line of the TOC:
if(CHM_Iterador==0)
{
previousLevel = currentLevel;
currentLevel = CHM_struc_niveles[CHM_Iterador];
futureLevel = CHM_struc_niveles[CHM_Iterador+1];
}
;//------This is for the start of the DIVs (always collapsable)------:
;//------This is for the start of the DIVs (always collapsable)------:
;//------This is for the start of the DIVs (always collapsable)------:
;//------This is for the start of the DIVs (always collapsable)------:
if( currentLevel > previousLevel) ;//If we go up a level...
{
if(previousLevel==1) ;//If it's the first level we go up...
{
document.write("<div id=\"" + (CHM_Iterador-1) + "_leveler\" style=\"display:none\">\n");
document.write(writeSimpleInit());
}
else ;//If the level we go up starts from 2...
{
document.write("<div id=\"" + (CHM_Iterador-1) + "\" style=\"display:none\">\n");
document.write(writeSimpleInit());
}
}
if( currentLevel<=previousLevel) ;//If we go down one level...
{
document.write(writeSimpleInit());
}
;//------This is for the content of leaves/nodes------:
;//------This is for the content of leaves/nodes------:
;//------This is for the content of leaves/nodes------:
;//------This is for the content of leaves/nodes------:
;//If there are several contiguous lines at the same level,these
;//are resolved at the following loop, and we save space by
;//reducing the number of complete tables to write:
if(currentLevel==futureLevel) ;//If level has not changed...
{
while(v1)
{
document.write(writeContent(currentLevel, CHM_Iterador, CHM_Iterador));
if(futureLevel!=currentLevel)
{
;//How is that the table is correctly generated from the visual point
;//of view even WITHOUT this code???
;//Well, because that causes that each hyperlink gets its very single
;//table, even when there are contiguous entries at the same level; but
;//that certainly is NOT desirable nor economic:
v1=false; ;//Indicator to finish this loop
break; ;//We break this loop...
}
CHM_Iterador++;
adjustLevels();
}
}
if( (currentLevel!=futureLevel) && v1 )
{
document.write(writeContent(currentLevel, CHM_Iterador, CHM_Iterador));
}
;//------This is for the end of the HTML hyperlink tabbed entry------:
;//------This is for the end of the HTML hyperlink tabbed entry------:
;//------This is for the end of the HTML hyperlink tabbed entry------:
;//------This is for the end of the HTML hyperlink tabbed entry------:
document.write("</table>");
if(futureLevel<currentLevel) ;//If we go down one or more levels...
{
;//Absolute value to prepare ourselves for a -1 (that's the value
;//we introduced at the last entry of "CHM_struc_niveles[]" to mark
;//End Of TOC when we ran "structure_levels()" function):
for(rd=1; rd<=(currentLevel-Math.abs(futureLevel)); rd++)
{
;//It conveniently closes any number of open
;//DIVs whenever we go down levels; the number of
;//open DIVs to close is determined at the second
;//parameter of this "FOR".
document.write("</div>");
}
}
CHM_Iterador++;
}
;//------Write the custom HTML after TOC------:
;//------Write the custom HTML after TOC------:
;//------Write the custom HTML after TOC------:
document.write(CHM_HTMLfin); //global
;//Free the memory hold by this global variable:
CHM_HTMLfin = "";
;//This is sort of undeclaration of the array that holds the TOC.
;//We free the duplicate memory hold by this here (this is useless
;//now since we ALREADY generated the HTML TOC):
CHM_toc = new Array();
return; ;//Finish!!!
}
-
Finalmente configuramos el programa para que utilice un manejador de teclado que nos ayudará a emular clicks cuando se presione ENTER.
var KeyboardCode; ;//Global variable
;//Here we hook up the keyboard to the
;//"onkeydown" event, which in turn is
;//now controlled by the custom "pushedKey"
;//function:
document.onkeydown = pushedKey;
try ;//Specific for Mozilla/Netscape/Firefox family
{
document.captureEvents(Event.KEYUP);
}
catch(err){}
function pushedKey(key)
{
try ;//Specific for Mozilla/Netscape/Firefox family
{
keyboardCode=key.which;
}
catch(err){}
try ;//Specific for Internet Explorer
{
KeyboardCode=event.keyCode;
}
catch(err){}
}
-
No se... pero que no se inventaron el PDF para sobreponerse a esta limitante?
-
No; son problemas distintos.
Esta interfaz que estoy publicando está diseñada para ser mucho más editable que un archivo PDF, sin necesidad de herramientas especializadas; sino que utilizando las capacidades ya existentes de los navegadores web.
Al poner este programa bajo reflexión, se pueden distinguir muchas ventajas en casos muy específicos ante los archivos PDF. Por ejemplo, puede contener elementos dinámicos que un documento PDF común no tendría.
-
Seria bueno que nos pusieras un link donde este una demostracion de este programa :thumbsup:
-
Seria bueno que nos pusieras un link donde este una demostracion de este programa :thumbsup:
eso mismo me preguntaba yo adonde esta la prueba de concepto ???
-
Este es un programa mostrando el uso del programa ya armado. Cualquier modificación a la tabla de contenidos debe hacerse en el archivo toc.html.js, al arreglo CHM_toc[ctr++].
http://redir.no-ip.org/tmp/CHMEmulator.zip (http://redir.no-ip.org/tmp/CHMEmulator.zip)
-
Porke no podes este tema en un DOC o un PDF y eliminas tanto poste ke pusiste porke a mi me parece ganas de hacer más post ke tenes viejo, con todo respeto te lo digo. :thumbsup:
-
Todavía no he publicado el código formalmente. El programa de ejemplo que acabo de enviar tiene un código que no se puede entender.
Estoy esperando discutir las diferentes partes del código en este tema de modo de obtener una versión pulida y que cualquiera pueda entender fácilmente.
Sigo esperando sugerencias del código, preguntas o dudas para mejorar lo que he publicado aquí a medida que he documentado el código.
A propósito, he enviado las diferentes partes del código con el orden exacto en el que deben armarse en el programa final (pseudocompilado).
-
Estoy muy de acuerdo con esto :dntknow:
El programa de ejemplo que acabo de enviar tiene un código que no se puede entender.