Showing posts with label JavaScript. Show all posts
Showing posts with label JavaScript. Show all posts

Thursday, December 26, 2019

Fokus: Un script para resaltar lo resaltado

Fokus es un script interesante aunque el resultado final dependerá mucho de la página donde se quiera utilizar, tanto de su color de fondo como de la forma en que está estructurada. Lo que hace es resaltar cualquier cosa que uno haya seleccionado, cubriendo el resto de la página con una cierta opacidad.

Justamente, es esa opacidad lo que hace que el resultado sea variable porque está pensada para fondos claros y no posee opciones de configuración aunque, si se quiere, se podría modificar el script, buscando esta línea y colocando allí el color a utilizar en formato rgba():

v.fillStyle="rgba( 0, 0, 0, "+t+" )";
Por ejemplo, si quisierámos que fuera una opacidad en blanco, sería:
v.fillStyle="rgba( 255, 255, 255, "+t+" )";

El script no utiliza librería así que puede agregarse en cualquier sitio aunque, como usa la etiqueta canvas, no se verá en versiones inferiores de Internet Explorer. Lo podemos descargar desde github y basta agregarlo antes de </head>


REFERENCIAS:lab.hakim

Wednesday, December 18, 2019

Cambiar el favicon de modo dinámico

No sé hasta que punto esto tendrá utilidad alguna pero, se me ocurrió buscar en la web a ver si existía alguna forma sencilla de cambiar el favicon de una página; es decir, tener uno pro defecto y cambiarlo por otro ya sea por la acción de un usuario (un click en alguna parte) o de manera aleatoria.

Había muchas respuestas y dudas que, naturalmente, incluían diferencias entre los navegadores (Internet Explorer y Chrome son problemáticos), funciones complicadas, etc etc pero, en un foro, alguien propone una solución que funciona bastante bien en Firefox, Chrome y Opera y que se basa en este artículo.

La función sería esta:
<script>
var IE = navigator.userAgent.indexOf("MSIE")!=-1;
var favicon = {
change: function(iconURL){
if (arguments.length == 2){document.title = optionalDocTitle;}
this.addLink(iconURL, "icon");
this.addLink(iconURL, "shortcut icon");
if (!IE) {
if (!window.__IFrame){
__IFrame = document.createElement('iframe');
var s = __IFrame.style;
s.height = s.width = s.left = s.top = s.border = 0;
s.position = 'absolute';
s.visibility = 'hidden';
document.body.appendChild(__IFrame);
}
__IFrame.src = 'about:blank';
}
},
addLink: function(iconURL, relValue) {
var link = document.createElement("link");
link.type = "image/x-icon";
link.rel = relValue;
link.href = iconURL;
this.removeLinkIfExists(relValue);
this.docHead.appendChild(link);
},
removeLinkIfExists: function(relValue) {
var links = this.docHead.getElementsByTagName("link");
for (var i=0; i<links.length; i++) {
var link = links[i];
if (link.type == "image/x-icon" && link.rel == relValue) {
this.docHead.removeChild(link);
return;
}
}
},
docHead: document.getElementsByTagName("head")[0]
}
</script>
Una vez agregada, bastaría ejecutarla con algo así:
favicon.change('url_imagen')

Es simple; estoy usando imágenes en formato gif pero pueden usarse otras, incluyendo formatos ico:
<img onclick="favicon.change('http://www.google.com/favicon.ico');" src="http://www.google.com/favicon.ico" />

Para que sea aleatorio, colocamos las imágenes en un array y seleccionamos una cualquiera:
function favalea() {
// lista de imágenes a utilizar
misFavicons=new Array('url_imagen_1','url_imagen_2','url_imagen_3','url_imagen_4');
// elegimos una al azar y llamamos a la función
favicon.change(misFavicons[Math.floor(Math.random()*misFavicons.length)]);
}
Y una etiqueta cualquiera que la ejecute:
<span style="cursor:pointer;" onclick="favalea()">favicon al azar</span>
o ejecutamos la función cuando la página esté cargada:
window.onload = (function(){ favalea(); });

Thursday, October 31, 2019

prefix-free y basta de prefijos en el CSS

prefix-free es un script que habría que tener muy en cuenta ya que nos ayuda a resolver uno de los problemas más molestos a la hora de escribir reglas de estilo "modernas" ya que lo que hace es agregar de modo automático, los prefijos correspondientes para cada navegador de tal modo que no sería necesarios escribir algo así:
.una-regla {
background-image: -moz-linear-gradient(#000,#FFF);
background-image: -webkit-linear-gradient(#000,#FFF);
background-image: -o-linear-gradient(#000,#FFF);
background-image: -ms-linear-gradient(#000,#FFF);
background-image: linear-gradient(#000,#FFF);
}
y todo ese exceso de líneas (que, inevitablemente uno termina equivocando u olvidando) se transformaría en es esto:
.una-regla {
background-image: linear-gradient(#000,#FFF);
}
es decir, sólo deebría usarse la propiedad especificada por la w3.org y del resto, se encargará el script.

¿En que navegadores funcionará? En todos aquellos que usen ese tipo de prefijos, Firefox, Chrome, Safari, Opera, IE9 en adelante y las versiones móviles más comunes. Obviamente, como IE8 no soporta la mayoría de las propiedades CSS3, nada ocurrirá allí pero tampoco tendrá influencia alguna, todo seguirá como antes.

¿Funciona en Blogger? Si, no debería haber problemas ya que el script se ejecuta tanto sobre etiquetas <style> </style>, estilos externos agregados con la etiqueta LINK o incluso, en estilos agregados inline con el atributo style en la misma etiqueta.

¿Cómo lo usamos? Descargamos el script desde la página del desarrollador (es muy pequeño) y lo alojamos en un servidor:
<script src='URL/prefixfree.min.js' type='text/javascript'/>
o simplemente lo copiamos y pegamos en la plantilla entre etiquetas
<script type='text/javascript'>
//<![CDATA[
....... acá pegamos el contenido del archvo js .......
//]]>
</script>
y, en ambos casos, conviene hacerles caso a los desarrolladores y agregarlo justo antes de </head>

Tres ejemplo rápidos:
/* un fondo con gradiente */
#pf1{background-image:linear-gradient(#000,#FFF);}

/* una transición */
#pf2{font-size: 0;line-height: 100px;border-radius:0;background-color: #000;transition:all 1s;}
#pf2:hover{background-color:#F0F8FF;border-radius:50px;background-color: #F00;font-size: 80px;}

/* una animación*/
#pf3{background-color:#000;animation: recrojo 1s infinite alternate;}
@keyframes recrojo {from {background-color:#000;} to {background-color:#F00;}}

Tuesday, October 15, 2019

TinyScroller: Simple y personalizable

TinyScroller es un script muy sencillo que no requiere librerías extras y nos permite mostrar mucho contenido en un espacio pequeño tal como normalmente hacemos cuando usamos un contenedor con cierta altura dimensionada y le aplicamos la propiedad overflow para que se pueda ver utilizando una barra de desplazamiento.

El script es realmente pequeño, uno poco más de 50 líneas sin comprimir aunque el ZIP que lo contiene también incluye una versión minimizada.

Lo agregamos como cualquier otro, alojándolo en un servidor o directamente, antes de <head>:

<script type='text/javascript'>
//<![CDATA[
var TINY={};
function T$(id){return document.getElementById(id)}
function T$$$(){return document.all?1:0}
TINY.scroller=function(){
return{
init:function(a,c,b,s,d){
a=T$(a); a.c=c; a.s=s; c=T$(c); b=T$(b); s=T$(s); a.n=d||0;
b.style.display='block'; a.style.overflow='hidden';
var h=a.offsetHeight, t=c.offsetHeight;
if(t<h){
b.style.display='none'
}else{
a.m=h-t; a.d=t/h; s.style.height=(h*(h/t))+'px'; s.style.top=b.style.top=0;
s.onmousedown=function(event){TINY.scroller.st(event,a.id); return false};
s.onselectstart=function(){return false}
}
a.l=b.offsetHeight-s.offsetHeight
},
st:function(e,f){
var a=T$(f), s=T$(a.s); a.bcs=TINY.cursor.top(e); a.bct=parseInt(s.style.top);
if(a.mv){this.sp(f)}
a.mv=function(event){TINY.scroller.mv(event,f)};
a.sp=function(){TINY.scroller.sp(f)};
if(T$$$()){
document.attachEvent('onmousemove',a.mv); document.attachEvent('onmouseup',a.sp)
}else{
document.addEventListener('mousemove',a.mv,1); document.addEventListener('mouseup',a.sp,1)
}
if(a.d){s.className+=' '+a.n}
},
mv:function(e,f){
var a=T$(f), m=TINY.cursor.top(e)-a.bcs+a.bct, s=T$(a.s), c=T$(a.c);
if(m>=0&&m<a.l){
s.style.top=m+'px'; c.style.top=(m*-1*a.d)+'px'
}else if(m<0){
s.style.top=0; c.style.top=0
}else if(m>a.l){
s.style.top=a.l+'px'; c.style.top=a.m+'px'
}
},
sp:function(f){
var a=T$(f), s=T$(a.s); if(a.d){s.className=s.className.replace(' '+a.n,'')}
if(T$$$()){
document.detachEvent('onmousemove',a.mv); document.detachEvent('onmouseup',a.sp)
}else{
document.removeEventListener('mousemove',a.mv,1); document.removeEventListener('mouseup',a.sp,1)
}
a.mv=0;
}
}
}();
TINY.cursor=function(){
return{
top:function(e){
return T$$$()?window.event.clientY+document.documentElement.scrollTop+document.body.scrollTop:e.clientY+window.scrollY
}
}
}();
//]]>
</script>

Y lo usarmemos de este modo:
<div id="ejemplo-scroll" class="scroll">
<div id="ejemplo-scrollcontent" class="scrollcontent">
....... acá pondremos nuestro contenido .......
</div>
<div id="ejemplo-scrollbar" class="scrollbar">
<div id="ejemplo-scroller" class="scroller"></div>
</div>
</div>
e inmediantamente debajo, llamamos a la función que en este caso, sería así:
<script type="text/javascript">TINY.scroller.init('ejemplo-scroll','ejemplo-scrollcontent','ejemplo-scrollbar','ejemplo-scroller','buttonclick');</script>
Eso, lo haremos siempre del mismo modo, con la misma sintaxis, colocando en la función los cinco parámetros que son los IDs que hemos elegido:

el ID del contenedor que en este caso llamé ejemplo-scroll
el ID del contenido que llamé ejemplo-scrollcontent
los IDs de lso DIVs auxiliares que mostrarán la barra de desplazamiento y el botón: (ejemplo-scrollbar y ejemplo-scroller)
y la clase de ese botón (buttonclick)

Por último, necesitamos el CSS que es lo que podemos personalizar y que en este caso, rearmé agregando clases par que, de esa forma, pudieran mostrarse con distintos tamaños y detalles gráficos:
<style>

/* las reglas genéricas */
.scroll { /* el contenedor */
overflow: auto;
position: relative;
}
.scrollcontent { /* el contenido */
position: absolute;
z-index: 200;
}
.scrollbar { /* la barra de desplazamiento es una imagen */
background:url(URL_scroll-bg.gif);
display: none;
float: right;
position: relative;
width: 15px;
z-index: 100;
}
.scroller { /* el botón de desplazamiento también es una imagen */
background-color: #CCC;
background-image: url(URL_scroll-arrows.gif);
background-position: 50% 50%;
background-repeat: no-repeat;
cursor: pointer;
position: absolute;
top: 0;
width: 15px;
}
.buttonclick { background-color:#BBB; }

/* y defino los anchos, altos y otros detalles de cada uno de elllos */
#ejemplo-scroll { /*
background-color: #000;
margin: 0 auto;
height: 200px; /* el ancho */
width: 300px; /* el alto */
}
#ejemplo-scrollcontent {
width:275px; /* el ancho del contenedor menos el ancho de la barra de desplazamiento */
}
#ejemplo-scrollbar {
height: 200px; /* el mismo alto que el contenedor */
}

</style>

Bastaría establecer otros valores para crear otro modelo y usarlo en la misma página:
#otro-scroll{
background-color: #222;
border: 2px solid #000;
height: 270px;
margin: 0 auto;
outline: 1px solid #666;
width: 600px;
}
#otro-scroll{width: 575px;}
#otro-scroll{height: 270px; }

Tuesday, October 8, 2019

Agregar fullscreen a distintos elementos

Mostrar contenido en pantalla completa no es algo exclusivo de los videos incrustados ya que puede hacerse sobre cualquier otro contenido aunque siempre veremos la advertencia del navegador que nos avisa que esta opción está en uso y que podemos volver atrás utilizando la tecla ESC.

Friday, September 6, 2019

oridomi: Contenidos plegables

oridomi es un script para animar cualquier tipo de contenido, plegándolo con diferentes efectos, como si fueran hojas de papel pero, claro está, esto sólo ocurrirá en navegadores que soporten las nuevas propiedades de CSS3.

Aunque la documentación del script es abundante ya que se explica cada función de modo detallado, lamentablemente, es poco lo que se indica del modo en que debe usarse y las distintas opciones pero veamos lo que dicen.

Para empezar, oriDomi funciona con o sin librerías anexas así que, luego de agregar el script (el minimizado o el normal) que podemos descargar de Github, debemos indicar cual o cuales serán los contenidos a los que se aplicará y esto, lo hacemos estableciendo una clase o un id. Por ejemplo si lo usara en este tipo de contenido:
<div id="ejemplo" class="ejemplo"><img src="una_imagen" /></ldiv>
debajo, pondría lo siguiente:
<script>var domi = new OriDomi(document.getElementById('ejemplo'));</script>
o bien esto si se usan clases en lugar de ids:
var domi = new OriDomi(document.getElementsByClassName('ejemplo')[0]);
aunque es más sencillo usando jQuery
var $domi = $('#ejemplo').oriDomi();
Y si quiera aplciarlo a varios contenidos distintos, sólo debería usar variables diferentes para cada uno:
var $domiUNO = $('#ejemplo').oriDomi();
var $domiOTRO = $('#otro-ejemplo').oriDomi();
Inicializado de ese modo, las opciones serán las que tiene por defecto pero, pueden ser modificadas; por ejemplo:
var $domi = $('#ejemplo').oriDomi({ vPanels: 3, hPanels: 10, perspective: 200, speed: 500, shading: false });
donde:

hPanels es la cantidad de secciones horizontales
vPanels es la cantidad de secciones verticales
speed es la velocidad
perspective es el valor de la perspectiva
shading indica si se agregarán sombras o no

Todo muy lindo pero ¿cómo lo usaría? Ahí, ya depende de lo que uno quiera hacer. Si sólo deseo mostrar ese contenido (imagen, texto, casi cualquier otra cosa simple o más o menos compleja) bastaría llamar a la función correspondiente, por ejemplo, algo así:
$domi.oriDomi('stairs',50,'left');
donde $domi es el nombre de la variable que le asignamos ($domiUNO, $domiOTRO); .oriDomi es la función genérica y lo que se encuentra entre paréntesis es efecto a usar, sus parámetros y opciones.

Los parámetros son números (positivos o negativos) que indican el ángulo y las opciones básicas indican el sentido de la rotación (left, right, top, bottom) siendo left la opción por defecto.

Los efectos posibles son varios y estos son los que se muestran en el demo inferior:
$domi.oriDomi('accordion', -40, 'right');
$domi.oriDomi('curl', 70, 'left');
$domi.oriDomi('ramp',50, 'top');
$domi.oriDomi('collapse','left');
$domi.oriDomi('stairs',50,'left');
$domi.oriDomi('fracture',30,'right');
$domi.oriDomi('twist',40,'left');
$domi.oriDomi('reveal', -50, 'right');
Hay otros como collapseAlt, foldUp, unfold y uno en particular nos permite restaurar el contendido, o se, volverlo a su estado original:
$domi.oriDomi('reset');

Friday, July 26, 2019

Algunas librerías para manejar la etiqueta Canvas

Estas son algunas librerías que podrían ayudar a manejar la etiqueta canvas de modo más simple, entendiendo que simple no significa fácil.

EaselJS es una de las más completas y modernas, enfocada básicamente a la parte gráfica. En la página de los autores se pueden ver muchos demos online como este.

Artisan JS es más sencilla y las funciones son limitadas pero bastante intuitivas. Puede verse un ejemplo de su funcionamiento en este generador de wallpapers.

jCanvaScript provee muchos métodos y funciones que permite generr contenido en cualquier plataforma incluyendo móviles aunque, como en todos estos casos, para Internet Explorer se requieren librerías extras como ExCanvas. Incluye animaciones drag and drop y manejo de eventos tanto del mouse como del teclado.

Saturday, July 13, 2019

¿Google no funciona? Cargar una librería alterna

Cargar las librerías desde los repositorios de Google usando las Google AJAX Library API es algo que se ha generalizado a tal punto que incluso los sitios "más grandes" utilizan ese método, transfiriéndoles a ellos la responsabilidad de mantener el sistema funcionando.

Pero ¿qué pasaría si un dia dejan de funcionar?

Seguramente, sería el pre-anuncio de un apocalipsis o algo por el estilo pero, de todos modos, en net.tutsplus.com nos muestran una alternativa que permitiría cargar un archivo alterno alojado en otro servidor y que deberíamos tener como respaldo ante eventuales catástrofes. En el caso de jQuery, sería algo así:
<script src="http://ajax.googleapis.com/ajax/libs/jquery/1/jquery.min.js"></script>
<script>!window.jQuery && document.write('<script src="URL_ARCHIVO"><\/script>')</script>
Dudo mucho que tal cosa sea necesaria pero ... por las dudas ...

Wednesday, July 10, 2019

Jugando con el botón de Pinterest

Una de las modas de estos nuevos tiempos es el uso de redes sociales, pseudo-sociales y todos esos sitios donde se comparten cosas. Algunos son exitosos porque "los usuarios los usan" y otros pasan al olvido rápidamente; hacia donde vamos o cuál será el modelo de internet que tendremos en unos años vaya uno a saber, por ahora seguimos caminando, probando y viendo de que se trata todo esto.

Uno de esos servicios que se está imponiendo es Pinterest y el botoncito para compartir ya se ve en muchos sitios.

Colocarlo es sencillo, se hace del mismo modo que con cualquiera de ellos, copiando y pegando el código que ofrecen y listo, funcionará sin problemas aunque , para mi gusto, es muy lento.

La forma de aplicarlo a Blogger la pueden ver en dos artículos escritos por Oloman donde se explica detalladamente su uso y las variantes que pueden elegirse: Pinterest, botón que se ve y funciona y Otras opciones para instalar el botón de Pinterest.

Ahora bien, para jugar un poco, me puse a ver si era posible hacer lo mismo pero de modo más específico, es decir, ver si podía agregarse ese botón a determinadas cosas y no a los posts en general; por ejemplo, adosar ese botón sólo en ciertas imágenes que uno quisiera que fueran compartidas y para ello, recurro a jQuery porque no se me ocurre nada más fácil.

El resultado, será algo como esto:


¿Cómo se identifica qué imagen quiero compartir y cuál no? Simplemente, le agrego una clase a la etqiueta IMG que, en este caso, será class="pin":
<img class="pin" src="URL_IMAGEN" />
Obviamente, lo primero que debo hacer es colocar el script del servicio que va al final de la plantilla, antes de </body>:
<script src='//assets.pinterest.com/js/pinit.js' type='text/javascript'/>
Y para que esto funcione, el botón también lo voy a crear con JavaScript cuyo código colocaré antes de </head> o antes del script anterior.

Los datos que debemos enviar son tres:

url es la drección desde donde se envía es decir, nuestra página
media es la dirección de la imagen
description es un texto alternativo

Quiero enviarle esos tres datos y además, que al hacer click en el botón, no se abra la página de Pinterest en otra pestaña sino en una ventana tipo pop-up así que armo algo como esto:
<script type='text/javascript'>
//<![CDATA[

// esto evitará que el enlace se abra en otra pestaña
$(document).on('click', '.pin-it-button', function(e){
e.preventDefault();
})

// esto hará que el enlace se abra en una ventanita de tipo pop-up
$(document).on('click', '.pinimg', function(e){
var url = $(this).attr('rel');
window.open(url,"pinshare","toolbar=0,status=0,width=620,height=320");
})

// y cuando se cargue la página
$(document).ready(function(){

// buscaremos todas las imágenes de los posts que tengan la clase "pin"
$('.post-body img.pin').each(function() {

// con estos datos vamos a armar la dirección url que debe enviarse a Pinterest
var post = location.href; // la dirección de nuestra página
var src = $(this).attr('src'); // la imagen a compartir
var texto = document.title; // la descripción será el título de la página
if($(this).attr('alt')) {
// y si colocamos el atributo alt en la imagen, allí podríamos mostrar un texto especial; si existe, lo usamos
texto = $(this).attr('alt') + " : via MIBLOG";
}

// verifico si la imagen flota
var cssflotar = $(this).css('float');

// y creamos el botón con esos datos
var boton ="<a count-layout='none' class='pin-it-button' href='#'><img title='Pin It' src='//assets.pinterest.com/images/PinExt.png' class='pinimg' rel='http://pinterest.com/pin/create/button/?url="+post+"&amp;media="+src+"&amp;description="+texto+"' /></a>";
// la etiqueta A tiene un href vacio justamente para evitar que se abra
// el dato a enviar está en el atributo rel de la etiqueta IMG

// rodeamos nuestra imagen con una etiqueta SPAN
$(this).wrap('<span class="pinwrap"></span>');
// que tiene la misma propiedad flaot que la imagen
$(this).parent().css('float',cssflotar);
// y le adosamos el botón
$(this).after(boton);
// y si tiene, le sacamos la flotación a la imagen
$(this).css('float','none');
})

})

//]]>
</script>
Un poco de CSS para que el botón se superponga a la imagen y pueda aplicarse a cualquier imagen, centrada o flotante:
<style>
.pinwrap {
display: inline-block;
position: relative;
}
.pin-it-button{
bottom: 10px;left: 10px;
position: absolute;
}
</style>
Y terminamos.

Acá abajo, la imagen de la derecha puede compartirse y la de la izquierda no:

una imagen para compartir

Friday, June 28, 2019

spin.js: Script para generar Imágenes de carga

spin.js es un pequeño script que permite crear esas imágenes que uno ve a menudo cuando de indica que algo se está cargando y debemos esperar.

esta es una imagen


No parecería nada del otro mundo pero hay una diferencia sustancial; no genera imagenes sino animaciones con CSS o usando el lenguaje VML en el caso que estemos usando Internet Explorer incluyendo la versión 6 si es que aún hay dinosaurios caminando por la web.

Se integra fácilmente, basta agregar el script normal o minimizado que descargamos desde la página del autor y agregarlo antes de </head> ya sea, alojándolo en un servidor propio:
<script type='text/javascript' src='URL_spin.min.js'></script>
o copiando y pegando su contenido:
<script type='text/javascript'>
//<![CDATA[
....... acá copiamos y pegamos el contenido del archivo .......
//]]>
</script>
Ahora, podemos usarlo de dos modos, o agregamos definiciones globales para controlar su aspecto:
<script>
var opts = {
lines: 15, // la cantidad de líneas
length: 36, // el tamaño de cada línea
width: 8, // el grosor de las líneas
radius: 36, // el radio del círculo
color: '#FFF', // el color en formato RGB
speed: 1, // la velocidad
trail: 60, // el efecto luminosidad
shadow: false // habilitar o deshabilitar las sombras
};
</script>
Y generamos la imagen en un DIV:
<div id="spin1"></div>
<script>new Spinner(opts).spin(document.getElementById('spin1'));</script>

O bien podemos generar imágenes individuales, estableciendo opciones diferentes:
<div id="spin2"></div>
<script>new Spinner({color:'#FF0', lines: 12}).spin(document.getElementById('spin2'));</script>

<div id="spin3"></div>
<script>
new Spinner({color:'#77DF', lines: 15, length: 20, width: 6, radius: 20, speed: 2}).spin(document.getElementById('spin3'));
</script>

Friday, June 14, 2019

Resaltar el item del menú según la página actual

Si tenemos un menú personalizado donde se muestran enlaces a alguna entradas en particular o a alguna página estática pero no estamos usando el gadget de Páginas de Blogger ¿es posible resaltar el elemento actual de menú? ¿mostrar ese enlace con alguna característica gráfica especial?
Eso es lo que se ve en muchos menús donde se establece una clase CSS para diferenciar ese item en particular, el sistema detecta la página donde estamos y automáticamente, agrega esa clase; es simple pero, no funciona en Blogger porque el sistema no nos ofrece esa posibilidad salvo, como dije antes, en el gadget de Páginas.

Supongamos que tenemos un menú de este tipo, con enlaces a entradas y páginas estáticas entremezcladas:
<ul div id="mimenu">
<li><a href="http://miblog.com">inicio</a></li>
<li><a href="http://miblog.com/2010/01/ejemplo.html" class="ejemplo">ejemplo</a></li>
<li><a href="http://miblog.com/p/otra-pagina.html">otra pagina</a></li>
<li><a href="http://miblog.com/2019/06/final.html">final</a></li>
</ul>

Si tenemos ese tipo de menú común y corriente, con enlaces personales, para conseguir el mismo efecto deberíamos recurrir a JavaScript y el método más cómodo, seria utilizar jQuery ya que nos permite usar selectores sencillos.
var url = document.URL;
nos diría en que página estamos y algo como esto:
$('#mimenu a[href="'+url+'"]').addClass('actual');
nos permitiría agregar la clase llamada actual para diferenciar el enlace correspondiente.



Esta sería una simulación pero, la idea sería la misma, haciendo click acá, se resaltaría el item del menú de este mismo ejemplo.

Bastaría entonces, agregar el script debajo del menú en si mismo:
<script>
//<![CDATA[
var url = document.URL;
$('#mimenu li a[href="'+url+'"]').addClass('actual');
//]]>
</script>

Wednesday, May 22, 2019

Animando listas con Stroll

stroll es un script experimental creado por Hakimel que no pretende tener ningún uso práctico, simplemente, se trata de un efecto visual que funcionará sólo en los navegadores más modernos ya que hace un uso intensivo de las nuevas propiedades de estilo tales como transiciones, transformaciones y perspectivas.

Lo que permite es aplicar una serie de efectos a las listas que utilizan la propiedad overflow para mostrar sólo una parte del contenido y que el resto sea accesible mediante el uso de una barra de scroll vertical.

No tiene muchas explicaciones y en realidad, no son necesarias, podemos descargar el demo desde github y allí tendremos todo lo necesario para aplicarlo en nuestros propios proyectos. Para eso, basta tener dos cosas: los estilos y el script.

Los estilos se encuentran en el archivo stroll.min.css o stroll.css (son iguales) y no es necesario agregarlos todos, basta seleccionar el efecto deseado y descartar el resto. Lo más simple es copiar las reglas y agregarlas a nuestra plantilla.

El script también tiene dos versiones stroll.min.js y stroll.js; podemos usar cualquiera de ellas y la agregamos como siempre, antes de </head>

¿Y cómo lo usamos? Basta colocar la lista dentro de algún DIV contenedor al que identificamos mediante un ID y luego, llamar a la función:
<div class="demo">
<ul class="zipper">
<li>uno</li>
<li>dos</li>
<li>tres</li>
</ul>
</div>
<script>stroll.bind('#demo ul');</script>
Todos los efectos funcionan de la misma manera y se distinguen estableciendo el atributo class en al etiqueta UL; en esta entrada, hay tres ejemplos distintos: curl, helix y zipper.

Un último detalle extra a tener en cuenta: establecer las propiedades mínimas de las etiquetas UL y LI de la lista a la que vamos a aplicar el efecto; un ejemplo:
#demo ul {
height: 280px;
list-style-type: none;
margin: 0;
overflow-x: hidden;
overflow-y: scroll;
padding: 0;
position: relative;
width: 190px;
}
#demo ul li {
background-color: #B0B9C1;
color: #000;
font-size: 20px;
padding: 10px;
position: relative;
z-index: 2;
}
#demo ul li:nth-child(odd) {
background-color:#EEE;
}

Tuesday, April 16, 2019

Librerías: ¿Si? ¿No? ¿Cuál? ¿Por qué? Socorro!!!

Las librerías de JavaScript son un gran invento pero, no son otra cosa que herramientas, tan útiles o inútiles como cualquier otra. Ninguna de ellas es una solución universal, uno las puede agregar fácilmente pero debemos estar conscientes de lo que eso significa.

Primero que nada, hay que saber que no son elementos neutros. Una vez que decidimos usar una, la carga del sitio se incrementará, a veces de manera sustancial, ya que son archivos de cierto volumen, muchos de los cuales requieren de otros agregados es decir, de otros archivos que también se cargan; el caso típico es Prototype que suele ser combinado con Scriptaculous, bulider.js, effects.js, dragdrop.js, controls.js, slider.js y sound.js; todo eso suma unos 60/70KB; la versión no minimizada de jQuery pesa más o menos lo mismo pero, ninguna de ellas se compara con las decenas de scripts que se agregan de manera automática en Blogger o el peso que tienen los distintos servicios: botones de compartir, estadísticas, etc, etc.

En definitiva, según mi opinión, utilizar o no utilizar librerías no es una decisión que deba tomarse pensando en tiempos de carga o por lo menos, ese no es el elemento fundamental a tener en cuenta.

Obviamente, mientras seamos conscientes de las cosas, cualquier decisión es aceptable pero, mi experiencia personal me dice que las librerías tienen sentido sólo si vamos a usarlas de verdad; es decir, si vamos a sacarles provecho porque en eso reside su utilidad. Si sólo las agregamos para usar un efecto eventual, su utilidad se reduce; no es que esté mal pero entendamos que, de alguna manera, es un desperdicio.

Definir la librería a usar también implica una limitación básica; de ahí en más, estaremos "atados" a esa librería; si vamos a agregar alguna otra cosa, deberemos verificar que sea compatible.

Es muy usual que pregunten por que no anda algo y al mirar, uno ve que el sitio usa jQuery y quiere usar un plugin para Prototype o viceversa. Tiene que quedar claro que por lo general, las librerías de este tipo son incompatibles entre si, o usamos una o usamos otra y, si bien hay alguna posibilidad de usar dos o más juntas, esto no es conveniente de ninguna manera ya que sólo estaremos duplicando funciones, incrementando la carga del blog sin beneficio alguno y abriendo la puerta a conflictos que a veces no tienen solución. No vale la pena, lo que puede hacerse con una, seguramente puede hacerse con otra.

Y ese es problema ... si bien, lo que puede hacerse con una también puede hacerse con otra, no siempre es sencillo encontrar la respuesta porque a menos que sepamos cómo funcionan y nosotros mismos creemos nuestros propios scripts, encontrar las respuestas en la web puede ser una tarea imposible.

En un tiempo, no hace mucho, la mayoría de ellas tenían una difusión pareja y los desarrolladores las usaban de manera indistinta y según sus gustos personales pero, eso ha cambiado y la decantación propia de estas cosas ha transformado a jQuery en la nueva vedette hasta, casi casi, convertirla en una especie de standard que usan muchos sitios e incluso las grandes empresas, desde Google hasta Facebook. Por lo tanto, será más fácil encontrar información sobre esta librería que sobre cualquier otra lo cual no significa que sea obligatoria ni que sea la mejor.


En la web hay una tendencia a canonizar herramientas (navegadores, sistemas operativos, software, redes sociales) y las librerías no están exentas de esa plaga bastante ridícula. "El martillo es lo mejor y quien no lo usa es un tonto" ... cambien martillo por una marca cualquiera y verán de lo que hablo.

El problema de estas dicotomías es que quien pondera el martillo probablemente, sólo conoce el martillo y por lo tanto, cree que es una herramienta universal, única e irreemplazable, cosa que, cualquiera con dos dedos de frente sabe que es falso. Nada es mejor o peor en abstracto y la mayoría de estas cosas que insisto, sólo son herramientas, es buena o mala porque carecen de moral. Simplemente, me gustan o no me gustan, me resultan útiles o no y punto.

Es más ... me resultan útiles hoy ... ¿pero mañana?

Entonces, ¿si usaba una librería y ahora quiero cambiarla?

Ahhhh buena pregunta ...

Wednesday, April 10, 2019

Crear plugins para las entradas: insertar videos

Si solemos insertar videos en nuestro sitio y hacemos esto con regularidad, es bastante fácil crear una función que genere el código de modo estandarizado para evitarnos la tediosa tarea de copiar y pegar una y otra vez.

Monday, January 7, 2019

Caracteres "raros" en scripts y CSS

A veces, cuando se usan scripts, debemos escribir caracteres especiales como acentos y estos no se ven bien o aparece un signo de interrogación u otros símbolos raros. Por lo general, esto se resuelve si la codificación de caracteres es correcta pero lo lógico no siempre funciona.

En Blogger, los caracteres especiales suelen verse bien por lo que ese problema es difícil que se nos presente pero, cuando se trata de otros servicios, de archivos externos, las cosas pueden complicarse, sobre todo si queremos emplear caracteres especiales [1 2]

Por ejemplo, esto, suele verse bien y al hacer click en este enlace, se verán las letras de modo correcto:
alert(" á é í ó ú  ☺ ❤ ✛ ");
Si no es así y quiero usar caracteres de ese tipo, lo que debo hacer es escribirlos en un formato especial, las llamadas cadenas de escape que no son otra cosa que una barra invertida seguida de una letra y un número en formato hexadecimal. En el caso de los acentos o caracteres comunes, sería \x más el código Unicode de dos dígitos:

\xe1 es la letra á
\xe9 es la letra é
\xed es la letra í
\xf3 es la letra ó
\xfa es la letra ú

Algunas combinaciones generan caracteres especiales:

\n es un salto de linea
\t es una tabulación
\' es la forma de escribir comillas simples
\" es la forma de escribir comillas dobles
\\ es una barra invertida

De manera más genérica, podemos usar \u más el código Unicode en formato hexadecimal (cuatro dígitos):

\u00e1 es la letra á
\u00e9 es la letra é
\u00ed es la letra í
\u00f3 es la letra ó
\u00fa es la letra ú

lo que nos permitirá ver correctamente eso que antes no se podía:
alert(" \u263a \u2764 \u271b ");
En esta página, hay una lista muy completa de todos los caracteres, tanto símbolos como distintos alfabetos.

Aunque en el CSS no suelen usarse caracteres raros, hay un caso en que también son necesarios, cuando se utiliza la propiedad content junto con :after y :before

Allí, se usa el mismo criterio aunque sólo es necesario agregar la barra invertida seguida de los cuatro dígitos del código hexadecimal. Por ejemplo:
content: ":\24d1\24d4\24d5\24de\24e1\24d4";

content: ":after \263a \2724 \2602";
:after ☺ ✤ ☂
:ⓑⓔⓕⓞⓡⓔ