Showing posts with label JQuery. Show all posts
Showing posts with label JQuery. Show all posts

Friday, December 20, 2019

boingPic: Sólo un experimento

Que nadie se crea que esto tiene alguna utilidad práctica inmediata, es para pasar el rato, un experimento que usa jQuery y que no tiene mayores pretensiones. Creado por kelvinluck.com/.

¿Será que todo tiene que tener alguna utilidad?
<style>
/* este es el formulario superior */
#boing-container { text-align: center; }
#boing-container input {
background: #000;
border: 2px solid #444;
border-radius: 4px;
color: #CCC;
padding: 5px;
}
#boing-container input[type=text] {
text-align: center;
width: 400px;
}
#boing-container input[type=submit]{
background-image: -moz-linear-gradient(#888, #222);
background-image: -webkit-linear-gradient(#888, #222);
background-image: -o-linear-gradient(#888, #222);
background-image: -ms-linear-gradient(#888, #222);
background-image: linear-gradient(#888, #222);
cursor: pointer;
width: 80px;
}
#boing-container input[type=submit].loading{visibility:hidden;}
.error{
color: #F00;
font-style: italic;
margin: 5px 0;
}
/* este es el contenedor con la imagen y el efecto */
#picHolder{
height: 200px;
margin: 50px auto;
position: relative;
width: 200px;
}
.block {position: absolute;}
.default { /* los cuadraditos iniciales */
border: 1px solid #FFF;
height: 18px;
width: 18px;
}
</style>

<script>
// recordar que se debe tener jQuery cargado */
// boingPic.js - a javascript experiment by Kelvin Luck - http://www.kelvinluck.com/
$(function(){
var divs;
var $picHolder = $('#picHolder');
function initGrid(w, h, backgroundImage){
$picHolder.empty();
$picHolder.css({'width' : w,'height' : h});
w /= 10; h /= 10;
divs = [];
for (var i=0; i<10; i++) {
var t = i * h; var l = 0;
for (var j=0; j<10; j++){
var css = {top:t, left:l};
if (backgroundImage){
css.background = 'url(' + backgroundImage + ') no-repeat -' + l + 'px -' + t + 'px';
css.width = w; css.height = h;
}
var d = $('<div class="' + (backgroundImage ? '' : 'default ') + 'block" />').css(css);
d.data('t', t); d.data('l', l);
divs.push(d);
$picHolder.append(d);
l+=w;
}
}
}
initGrid(200, 200);
var mouseX = 1000; var mouseY = 1000;
$(document).bind(
'mousemove',
function(e){
var po = $picHolder.offset();
mouseX = e.pageX - po.left; mouseY = e.pageY - po.top;
}
);
var force = 1500;
setInterval(
function(){
var po = $picHolder.offset();
for (var i=0; i<divs.length; i++) {
var $d = divs[i];
var o = $d.offset();
var x = o.left - po.left; var y = o.top - po.top;
var xDif = mouseX - x; var yDif = mouseY - y;
var distance = Math.sqrt(xDif*xDif+yDif*yDif);
var tempX = x - (force/distance)*(xDif/distance); var tempY = y - (force/distance)*(yDif/distance);
$d.css('left', ($d.data('l') - x)/2+tempX); $d.css('top', ($d.data('t') - y)/2+tempY);
}
},
100
);
$imageUrl = $('#imageUrl');
$imageUrl.bind(
'focus',
function(e){if ($imageUrl.val() == 'direccion url de una imagen y click en cargar ...') {$imageUrl.val('');}}
).bind(
'blur',
function(e){if ($imageUrl.val() == '') {$imageUrl.val('direccion url de una imagen y click en cargar ...');}}
);
var $submitButton = $('#loadImage');
$submitButton.bind(
'click',
function(e){
$submitButton.addClass('loading');
var i = new Image();
$(i).bind(
'load',
function(e){
$submitButton.removeClass('loading');
var w = i.width; var h = i.height;
initGrid(w, h, $imageUrl.val());
}
).bind(
'error',
function(){
$submitButton.removeClass('loading');
var $errorMessage = $('<div class="error">la URL de la imagen no es valida</div>');
$submitButton.after($errorMessage);
$errorMessage.hide().slideDown('normal').animate(
{'opacity': .9}, 2000
).slideUp(
'normal', function(){$errorMessage.remove();}
);
initGrid(20, 20);
}
);
i.src = $imageUrl.val() || 'theresnoimagebythatname!';
return false;
}
);
}
);
</script>

<div id="boing-container">
<form>
<input type="text" id="imageUrl" value="direccion url de una imagen y click en cargar ..." />
<input type="submit" id="loadImage" value="cargar" />
</form>
</div>

<div id="picHolder"></div>

Monday, December 2, 2019

Nube de etiquetas con jQuery

Esta es una forma de crear una nube de etiquetas animadas utilizando jQuery publicada por devirtuoso.com y que, tal vez, con algunos cambios, podría aplicarse incluso a las etiquetas de Blogger, cosa que quedará para quien quiera investigar el asunto.

El HTML no es otra cosa que una lista común:
<div id="listaE">
<ul>
<li><a href="url_etiqueta_1">etiqueta 1</a></li>
<li><a href="url_etiqueta_2">etiqueta 2</a></li>
<li><a href="url_etiqueta_3">etiqueta 3</a></li>
<!-- continuamos agregando los distintos enlaces -->
</ul>
</div>
Y el CSS básico:
<style>
#listaE {
display:none;
overflow:hidden;
position:relative;
/* dimensionamos el contenedor y lo centramos */
margin:0 auto;
padding:20px 40px;
height:500px;
width:500px;
}
#listaE ul, #listaE li {
/* eliminamos cualquier propiedad por defecto de la lista */
list-style:none;
margin:0;
padding:0;
}
#listaE a {
position:absolute;
text-decoration: none;
/* establecemos color y tipo de fuente del texto */
color: #FFF;
}
#listaE a:hover {
/* y del efecto hover sobre los enlaces */
color:#FFF !important;
opacity: 1 !important;
}
</style>
Por último, el script en si mismo que ejecutamos cuando se termine de cargar la página:
<script>
$(document).ready(function(){
var element = $('#listaE a');
var offset = 0;
var stepping = 0.03;
var list = $('#listaE');
var $list = $(list);
$list.mousemove(function(e){
var topOfList = $list.eq(0).offset().top;
var listHeight = $list.height();
stepping = (e.clientY ) / listHeight * 0.2 - 0.1;
});
for (var i = element.length - 1; i >= 0; i--){
element[i].elemAngle = i * Math.PI * 2 / element.length;
}
setInterval(render, 20);
list.show();
function render(){
for (var i = element.length - 1; i >= 0; i--){
var angle = element[i].elemAngle + offset;
x = 120 + Math.sin(angle) * 30;
y = 45 + Math.cos(angle) * 30;
size = Math.round(20 - Math.sin(angle) * 20);
var elementCenter = $(element[i]).width() / 2;
var leftValue = (($list.width()/2) * x / 100 - elementCenter) + "px";
$(element[i]).css("fontSize", size + "pt");
$(element[i]).css("opacity",size/100);
$(element[i]).css("zIndex" ,size);
$(element[i]).css("left" ,leftValue);
$(element[i]).css("top", y + "%");
}
offset += stepping;
}
});
</script>

Friday, November 8, 2019

Algunos plugins para jQuery

Estos son algunos plugins que requieren jQuery para funcionar y que me han parecido interesantes para ir probando aunque se trata de cosas demasiado específicas como para intentar mostrar ejemplos concretos para cada uno de ellos así que ... a arremangarse e intentarlo.

Tinycon

No sé que utilidad puede tener aplicado a Blogger pero este plugin cambia el favicon agregándole una burbuja con algún tipo de dato variable.

jQuery Corner

Es un plugin que permite generar decenas de bordes distintos, simples o complejos ya predefinidos y, obviamente no funcionará en los navegadores que no admitan CSS3.

jPages

Un plugin muy completo que sirve para generar contenido paginado, algo que normalmente está reservado para lenguajes que se ejecutan del lado del servidor.

MediaElement.js

Complejo sistema que permite crear reproductores de audio y video utilizando sólo HTML y CSS e incluye soporte para Flash y Silverlight por lo que funciona incluso en navegadores que no soportan HTML5.

jCarousel

Un plugin para controlar el orden de cualquier lista que pueden ser estáticas o bien ser cargadas usando AJAX.


fitvidsjs

Un plugin muy liviano que permite transformar los videos incrustados en objetos fluidos que se adapten a cualquier contenedor.

infinity

Genera código que ayuda a controlar la forma en que se ven listas muy largas, usando animaciones suaves.


rotate3Di

Plugin para crear efectos 3D con rotaciones y animaciones



imagesLoaded

Una forma sencilla de determinar si una o varias imágenes se han cargado y actuar en consecuencia.


tooltipster

Un sistema completo para generar tooltips en cualquier tipo de etiqueta que incluso, funciona en viejas versiones de Internet Explorer.

Friday, October 4, 2019

simpleWeather: El tiempo en el blog con jQuery

simpleWeather es un plugin de jQuery que sirve para mostrar informacion sobre el estado del tiempo del tiempo en un lugar definido y que para eso, utiliza el API Weather feed de Yahoo.

El script es muy simple porque, en realidad, no genera la salida sino que simplemente obtiene los datos así que la parte complicada del asunto es que nosotros debemos armar el HTML correspondiente.

Una vez que agregamos el script a la plantilla, deberíamos crear la función que es lo que mostrará el resultado; básicamente es algo así:
$.simpleWeather({
location: 'xxxxxxxxxxx',
unit: 'c',
success: function(weather) { ... },
error: function(error) { ... }
});
donde location es la ciudad y unit indica la unidad de la temperatura.

Este es un ejemplo simple:
<script type="text/javascript">
//<![CDATA[
$(function() {
$.simpleWeather({
location: 'xxxxxxxxxxx',
unit: 'c',
success: function(weather) {
html = '<h2>'+weather.city+'</h2>';
html += '<img src="'+weather.image+'"/>';
html += '<p>'+weather.temp+'° '+weather.units.temp+'<span>'+weather.currently+'</span></p>';
$("#weather").html(html);
},
error: function(error) {
$("#weather").html('<p>'+error+'</p>');
}
});
});
//]]>
</script>
Así que ahora, bastaría colocar el DIV de salida allí donde quisiéramos mostrarlo:
<div id="weather"></div>
Y un poco de CSS:
<style>
#weather {
background-color: #456;
border: 4px solid #ABC;
overflow: hidden;
padding: 10px 20px 0;
position: relative;
text-align: center;
width: 185px;
}
#weather h2 {
color: #DEF;
font-family: Century Gothic;
font-size: 28px;
font-weight: normal;
letter-spacing: -3px;
margin: 0;
text-align: center;
}
#weather img {
margin-top: 10px;
}
#weather p {
color: #DEF;
font-family: Times New Roman;
font-size: 48px;
left: 80px;
letter-spacing: -6px;
margin: 0;
position: absolute;
top: 140px;
}
#weather p span {
color: #ABC;
display: block;
font-size: 20px;
letter-spacing: 0;
text-transform: lowercase;
}
</style>

Wednesday, September 25, 2019

Muchos feeds y un solo script para mostrarlos (2)

Tengo muchas direcciones de feeds y ahora, lo que quiero hacer es mostrarlos pero sin tener que escribir códigos especiales para cada uno de ellos y además quiero que se vean en un mismo lugar así que me aprovecho de jQuery y modifico un poco el script que se mostraba en esta entrada.

Allí, agregaré un par de funciones extras, una, llamada FEED_eliminartags() para que los contenidos puedan ser "recortados" y verlos como sumarios y otra para detectar la primera imagen que tengan FEED_primerimagen(); ambas cosas, son similares a cualquier otra función que interprete json que es el formato en que leeremos los feeds.

Agrego las funciones antes de </head>

<script type='text/javascript'>
//<![CDATA[
function FEED_primerimagen(cual) {
var t = "", s, a, b, c, d;
s = cual;
a = s.indexOf("<img");b = s.indexOf("src=\"",a);c = s.indexOf("\"",b+5);d = s.substr(b+5,c-b-5);
if((a!=-1)&&(b!=-1)&&(c!=-1)&&(d!="")) {t = d;}
return t;
}

function FEED_eliminartags(cual,longitud){
var r = cual.split("<");
for(var i=0;i<r.length;i++){
if(r[i].indexOf(">")!=-1){
r[i] = r[i].substring(r[i].indexOf(">")+1,r[i].length);
}
}
r = r.join("");
var sss = "", p;
var r2 = r.split(" ");
for(var i=0;i<r2.length;i++){
p = sss + r2[i] + " "
if(p.length>=longitud) {break;}
sss = p;
}
sss = $.trim(sss);
if(sss) {sss += " …" }
return sss
}

(function ($) {
$.fn.FeedEk = function (lasopciones) {
var opciones = {url: '', clase: '', cantidad: 3, lenres: 120};
if (lasopciones) {$.extend(opciones, lasopciones)}
var elID = $(this).attr('id');
if (opciones.url == null || opciones.url == '') {
$('#' + elID).empty();
return
}
$.ajax({
url: 'http://ajax.googleapis.com/ajax/services/feed/load?v=1.0&num=' + opciones.cantidad + '&output=json&q=' + encodeURIComponent(opciones.url) + '&callback=?',
dataType: 'json',
success: function (data) {
$('#' + elID).empty();
$.each(data.responseData.feed.entries, function (i, entry) {
var laimagen = FEED_primerimagen(entry.content);
var contenido = FEED_eliminartags(entry.content,opciones.lenres);
var salida = "<div class='ItemFeed "+opciones.clase+"'>";
salida += "<div class='ItemTitle'><a href='" + entry.link + "' target='_blank' >" + entry.title + "</a></div>";
salida += "<div class='ItemContent'>";
if(laimagen){
salida += "<img src='"+ laimagen +"' />";
}
if(contenido){
salida += "<p>" + contenido + "</p>";
}
salida += "</div>";
salida += "</div>";
$('#' + elID).append(salida);
})
}
})
}
})(jQuery);
//]]>
</script>

Y en un elemento HTML, entrada, página estática o donde quiera que se muestren, el HTML que no es otra cosa que un DIV vacío y una serie de enlaces:
<div id="divRss"></div>

<div id="fenlaces">
<a href="#" rel="1" class="ftwitter"> Twitter usuario </a>
<a href="#" rel="2" class="ftwitter"> Twitter favoritos </a>
<a href="#" rel="3" class="ftwitter"> Twitter menciones </a>
<a href="#" rel="4" class="fyoutube"> YouTube usuario </a>
<!-- coloco todos los enlaces que quiera -->
<a href="#" rel="14" class="fstumble"> StumbleUpon blog </a>
</div>
Ahora, faltaría definir una lista de direcciones urls con los distintos feeds; uso un array o cualquier otro sistema:
<script type="text/javascript">
var lista_feeds=new Array();
lista_feeds[0] = "";
lista_feeds[1] = "https://twitter.com/statuses/user_timeline/usuario.rss";
lista_feeds[2] = "https://api.twitter.com/1/favorites/usuario.rss";
lista_feeds[3] = "http://search.twitter.com/search.rss?q=to:@usuario";
lista_feeds[4] = "https://gdata.youtube.com/feeds/api/users/usuario/uploads";
// ....... sigo agregando las direcciones que quiera usar
lista_feeds[14] = "http://www.stumbleupon.com/rss/stumbler/nombre/likes";

// y el evento de jQuery apra detectar el click en esos enlaces
$('#fenlaces a').live('click', function(e) {
e.preventDefault(); // evito qe se ejecuta el href del enlace
var url = lista_feeds[$(this).attr('rel')]; // leo el número de orden de la lista (1, 2, 3, 4, etc)
var clase = $(this).attr('class'); // leo la clase de ese enlace
// y ejecuto la función para leer los feeds
// donde cantidad es el número de entradas a leer y lenres es la longitud máxima
$('#divRss').FeedEk({url:url, clase:clase, cantidad: 3, lenres:200 });
});

// y por defecto, muestro el primero de la lista
$(document).ready(function() {
$('#fenlaces a').first().click();
});
</script>
Por último, como siempre, el CSS que es lo que termina de personalizar las cosas:
<style>
#divRss { /* el contenedor */
background-color: #EEE;
border: 1px solid #000;
margin: 0 auto;
outline: 3px solid #ABC;
padding: 10px;
width: 350px;
}
#divRss .ItemFeed { /* cada entrada */
border-bottom: 1px dotted #000;
color: #666;
padding: 5px 0;
}
#divRss .ItemFeed:last-child {border: none;}
/* y los detalles (título, contenido e imagen)
#divRss .ItemTitle { }
#divRss .ItemTitle a { }
#divRss .ItemContent { }
#divRss .ItemContent p { }
#divRss .ItemContent img {height: auto; width: 100%;}
</style>
Como los datos que nos muestran esos feeds pueden ser variables, la clase que se envia a la función, permite que los mostremos con alguna diferencia; por ejemplo:
#divRss .ItemFeed.ftwitter { }
#divRss .ItemFeed.fyoutube { }
#divRss .ItemFeed.fyoutube .ItemTitle { }
#divRss .ItemFeed.fstumble img { }

Tuesday, September 24, 2019

Muchos feeds y un solo script para mostrarlos (1)

Hace ya unos cuantos días, en labnol.org publicaban un artículo donde enumeraba una larga serie de direcciones de feeds a los que podía accederse o leer su contenido; feeds de distintos servicios que, como casi todos ellos, son públicos y por lo tanto, podemos mostrarlos.

Para hacer eso, como los feeds suelen tener formatos diferentes, un método efectivo es usar la idea que se mostraba en esta entrada que no es otra cosa que un pequeño script que utiliza jQuery para enviar esa dirección de feeds a un API de Google que nos devuelve siempre un formato único; de tal modo, podremos emplearlo sin tener que tener en cuenta esas diferencias o andar averiguando en que etiquetas están los distintos datos.

Es cierto que el API no es muy flexible pero, lo que nos devuelve es más que suficiente para armar un gadget que nos permita mostrar una lista de feeds de distinto tipo en en el mismo espacio.

Empezamos con algunas de las direcciones de la lista de feeds:

las últimas actualizaciones de Twitter:
https://twitter.com/statuses/user_timeline/usuario.rss
los favoritos de Twitter:
https://api.twitter.com/1/favorites/usuario.rss
las menciones de Twitter:
http://search.twitter.com/search.rss?q=to:@usuario
cualquier búsqueda o hashtags) de Twitter:
http://search.twitter.com/search.rss?q=palabra
los últimos videos subidos a YouTube:
https://gdata.youtube.com/feeds/api/users/usuario/uploads
videos de YouTube con cierta etiqueta:
https://gdata.youtube.com/feeds/api/videos/-/etiqueta
cualquier búsqueda en YouTube:
https://gdata.youtube.com/feeds/api/videos?q=palabra&orderby=relevance
lo mismo pero ordenadas por fecha:
https://gdata.youtube.com/feeds/api/videos?q=palabra&orderby=published
lo mismo pero ordenadas según visitas:
https://gdata.youtube.com/feeds/api/videos?q=palabra&orderby=viewCount
últimas actualizaciones de una página de Facebook:
https://www.facebook.com/feeds/page.php?format=atom10&id=ID_pagina
imágenes subidas a Pinterest:
http://pinterest.com/usuario/feed.rss
imágenes subidas a Flickr:
http://api.flickr.com/services/feeds/photos_public.gne?id=ID_usuario
imágenes de Flickr con cierta etiqueta:
http://api.flickr.com/services/feeds/photos_public.gne?tags=etiqueta
imágenes de Instagram con cierta etiqueta:
http://instagr.am/tags/etiqueta/feed/recent.rss
cualquier búsqueda de Picasa:
http://photos.googleapis.com/data/feed/base/all?alt=rss&kind=photo&q=palabra
últimas entradas en Tumblr:
http://nombre.tumblr.com/rss
últimas entradas en WordPress.com:
http://nombre.wordpress.com/feed/
últimas actualizaciones en StumbleUpon:
http://www.stumbleupon.com/rss/stumbler/usuario/likes

En todos los casos, lo que debe hacerse es cambiar el dato en amarillo por el que corresponda, ya sea nuestro nombre de usuario, ID, etiqueta o palabra a buscar.

Y lo que faltaría es ver cómo se podrían usar ...

Tuesday, September 17, 2019

Convertir textos en enlaces utilizando jQuery

Esta es una pequeña función muy interesante que usa jQuery para convertir cualquier dirección URL escrita como texto en un enlace. Es decir, escribimos esto:
http://jquery.com/
y se generará esto:
<a href="http://jquery.com/">http://jquery.com/<>
El código de la función sería el siguiente:
$.fn.crearLinks = function() {
var regexp = /((ftp|http|https):\/\/(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?)/gi;
this.each(function() {
$(this).html(
$(this).html().replace(regexp,'<a href="$1">$1</a>')
);
});
return $(this);
}
que ejecutaremos de acuerdo a nuestras necesidades; por ejemplo, si sólo quisiéramos que lo hiciera en determinadas circunstancias, bastaría indicar la clase o ID del contenedor; en este ejemplo uso un DIV con la clase crearlinksdemo así que sería:
$(document).ready(function() {
$(".crearlinksdemo").crearLinks();
});


Morbi vitae est purus. Aliquam at leo nibh. Maecenas ultrices sem est, eget consectetur ante. Nulla lacus turpis; ullamcorper non tincidunt eget, mattis non ligula via http://vagabundia.blogspot.com/

Aliquam erat volutpat. Aliquam hendrerit dolor sed nisl dapibus condimentum? Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Donec sollicitudin odio a ante semper eu interdum ipsum porta. Phasellus at libero quis sapien imperdiet faucibus auctor nec est Blogger http://www.blogger.com/home

Nullam vel nunc eu tellus vehicula congue. Quisque ut odio felis, vitae tempus ipsum? Quisque venenatis viverra augue, quis tempor lacus iaculis id? Pellentesque luctus egestas tortor, vehicula cursus leo mattis et. Sed molestie purus sed urna iaculis eu luctus nisl tincidunt. Proin eu massa velit, nec fermentum ipsum orci aliquam http://jquery.com/



Pero podría ser algo más global como tods las entradas de Blogger:
$(".post").crearLinks();
o todas las etiquetas P o cualquier cosa:
$("p").crearLinks();
Y, obviamente, podríamos modificar la función para que también se abrieran en otra pestaña:
$(this).html().replace(regexp,'<a target="_blank" href="$1">$1</a>')
agregarle otros atributos:
$(this).html().replace(regexp,'<a rel="nofollow" target="_blank" href="$1">$1</a>')
o una clase para definir reglas de estilo especiales:
$(this).html().replace(regexp,'<a class="enlacetexto" target="_blank" href="$1">$1</a>')

REFERENCIAS:webintenta.com

Monday, September 2, 2019

Dos sliders con efectos 3D

Las cosas se vuelven cada vez más complejas, las alternativas que combinan CSS y scripts van aprovechando las nuevas posibilidades que nos dan los navegadores más modernos y la imaginación de los desarrolladores hace el resto, presentándonos alternativas con las que nunca habíamos soñado.

Lamentablemente, a veces, esas complejidades se extienden más allá de lo razonable y se nos ofrecen efectos que uno trata de mirar y así, a simple vista, nos abruman porque nos posibilitan la descarga de los demos completos pero estos son excesivos, incluyen demasiadas cosas y hay que irlos simplificando para llegar al meollo del asunto. Lo curioso es que cuando se llega a ese punto, todo es más simple de lo que parecía y uno se queda pensando ¿por que no empezarán por lo sencillo?

Ese es el caso de estos dos scripts que utilizan jQuery para generar una serie de efectos gráficos muy llamativos.

El primero se llama Adaptor y es un slider de imágenes con algunos efectos originales tales como Vertical 3D scroll y Horizontal 3D scroll. El demo completo puede verse en este enlace.

Acá, intento usar uno de ellos, el llamado scrollVert3d:

Teniendo jQuery en la plantilla, sólo se requiere un script, el que se llama box-slider-all.jquery.min.js que, en este caso, alojé en un servidor externo como DropBox.

<!-- el CSS lo ponemos antes de </head> -->
<style>
<!-- los valores de width y height dependerán del tamaño de las imágenes a mostrar -->
#viewport-shadow {
position: relative;
width: 635px;
}
#viewport, #box, .slide {
list-style:none;
height: 375px;
width: 635px;
}
.slide img{
height: 375px;
width: 600px;
}
#viewport {overflow: hidden;}
#time-indicator {
background-color: #2EDBAC;
height: 3px;
left:0px;
position: absolute;
top:388px;
width: 0px;
}
</style>

<!-- el HTML lo ponemos en un post o en un elemento HTML -->
<div id="viewport-shadow">
<div id="viewport">
<ul id="box">
<li class="slide"><img src="URL_imagen1"></li>
..... todas las imágenes que uno quiera .......
</ul>
</div>
<div id="time-indicator"></div>
</div>

<!-- el script lo ponemos al final de la pagina o después del HTML -->
<script src="URL_box-slider-all.jquery.min.js"></script>
<script>
$(function () {
var $box = $('#box'), $timeIndicator = $('#time-indicator'), slideInterval = 5000;
var switchIndicator = function ($c, $n, currIndex, nextIndex) {$timeIndicator.stop().css('width', 0);};
var startTimeIndicator = function () {$timeIndicator.animate({width: '600px'}, slideInterval);};
$box.boxSlider({
speed: 1000, autoScroll: true, timeout: slideInterval, effect: 'scrollVert3d', blindCount: 15, onbefore: switchIndicator, onafter: startTimeIndicator
});
startTimeIndicator();});
</script>

No hay manera de explicar los detalles uno por uno y hay que ver la página del autor para descubrir las distintas opciones pero, si se quiere utilizar de modo elemental, no hace falta mucho más que eso.

El otro script se llama Flux y también es un slider que incluye sofisticadas transiciones en 3D y cuyo demo original con todas las alternativas podemos ver acá.

En este caso, sólo intentaé usar el último, uno llamado Turn:

El script que necesitamos es flux.min.js que también podemos alojar el un servidor o colocar directamente en la plantilla y, como en el anterior, necesitamos tener jQuery instalado.

<!-- el CSS y el script los ponemos antes de </head> -->
<style>
div.surface{
-moz-box-sizing:content-box;
-webkit-box-sizing:content-box;
-ms-box-sizing:content-box;
box-sizing:content-box
width:100%;
}
</style>
<script src='URL_flux.min.js' type='text/javascript'/>
<script type='text/javascript'>
//<![CDATA[
$(function(){
if(!flux.browser.supportsTransitions)
alert("Flux Slider requires a browser that supports CSS3 transitions");
window.f = new flux.slider('#slider', {autoplay: false,pagination: false});
$('#trans3d').bind('click', function(event){
event.preventDefault();
if(!flux.browser.supports3d){alert("Teste navagedor no soporta transiciones");return;}
window.f.next('turn');
});
});
//]]>
</script>

<!-- y el HTML lo ponemos donde se nos ocurra mostrar el slider-->
<div class="container">
<div id="slidercontainer">
<div id="slider">
<img src="URL_imagen1" />
..... todas las imágenes que uno quiera .......
</div>
<a id="trans3d" href="#turn" class="new">Turn</a></div>
</div>

Monday, August 12, 2019

jQuery ProQuo:UTILISIMO plugin Twitter

jQuery ProQuo es un plugin que permite convertir cualquier parte de una página web en un contenido "compartible" en Twitter.

Obviamente, requiere el uso de la librería jQuery y el script es bastante pequeño. Para usarlo, basta agregarlo antes de </head> y luego, definir la etiqueta y/o clase a la que se aplicará; por ejemplo, si quiisera que el contenido que de una etiqueta cuya clase es compartir fuera "tweeteable", debería llamar a la función de este modo:
<script>
$(document).ready(function(){
  $('.compartir').proQuo();
 });
</script>
Y luego, la podría usar en cualquier etiqueta y se agregaría un enlace con el texto Tweet this al final de ella:
<p class="compartir"> ....... cualquier cosa ....... </p>
Algunas opciones extras nos permiten usar el botón clásico de Twitter en lugar de ese texto:
$('.compartir').proQuo({useTwitterButton: true});
agregarle comillas:
$('.compartir').proQuo({ useTwitterButton: true, addCurlyQuotes: true });
establecer el texto a mostrar:
$('.compartir').proQuo({ tweetLabel: 'mi texto' });
o incluso personalizar algunas de las funciones propias de Twitter, detalles estos que se explican en los ejemplos que hay en al página del desarrollador.

No hay limitaciones en cuanto a la cantidad de tipos definidos así que pueden agregarse varios, cada uno con sus opciones propias:
$('.compartir').proQuo({ useTwitterButton: true });
$('.OTROcompartir').proQuo({ tweetLabel: 'mi texto' });
Y luego, si queremos, bastaría darle algún tipo de formato especial a esas clases para hacerlas evidentes o resaltarlas.

Friday, August 2, 2019

Adipoli: Plugin de jQuery para crear efectos hover

adipoli es un plugin para jQuery que facilita la tarea de crear efectos hover sobre las imágenes ya que dispone de una serie de transiciones predefinidas que podemos usar con facilidad.

Obviamente, se requiere tener jQuery; si no es así, puede ser cargado desde las API de Google agregando lo siguiente antes de </head>
<script src='http://ajax.googleapis.com/ajax/libs/jquery/1/jquery.js' type='text/javascript'></script>
Descargamos el ZIP con el plugin, lo alojamos en un servidor externo y lo agregamos a continuación de lo anterior:
<script src="URL_jquery.adipoli.min.js" type="text/javascript"></script>
o lo añadimos directamente en la plantilla, copiando y pegando el contenido del archivo:
<script type='text/javascript'>
//<![CDATA[
.. acá el contenido del archivo ...
//]]>
</script>
Por último unas pocas reglas de estilo que podemos agregar directamente en la plantilla y que no es necesario personalizar:
<style>
.adipoli-wrapper {display: inline-block; margin:auto; position:relative;}
.adipoli-wrapper>img {position: absolute; z-index: 1;}
.adipoli-before {position: absolute; z-index: 5;}
.adipoli-after {position: absolute; z-index: 10;}
.adipoli-slice {display:block;height:100%;position:absolute;z-index:15;}
.adipoli-box {display:block;position:absolute;z-index:15;}
</style>
¿Y cómo lo usamos? Sólo hay que agregar la función a cualquier selector así que sigo poniendo códigos:
<script type='text/javascript'>
//<![CDATA[
$(document).ready(function() {
$('.efecto1').adipoli({'startEffect' : 'overlay','hoverEffect' : 'sliceUpDown'});
$('.efecto2').adipoli({'startEffect' : 'overlay','hoverEffect' : 'fold'});
});
//]]>
</script>
En esos ejemplos, todas las imágenes cuyo atributo class es efecto1 se animarán de cierto modo y las que tengan la clase efecto2 de otro. Lo mismo podría hacer en Blogger para crear animaciones automáticas de las imagenes subidas ya que esta, tienen una clase denominada separator así que con esto, les agragría uno de los efectos:
$('.separator img').adipoli({'startEffect' : 'normal','hoverEffect' : 'popout'});
Lo que se ve entre las llaves son las opciones que, básicamente son dos, la primera indica como se verá la imagen inicialmente (normal, transparent, overlay o grayscale sólo si el documento es de tipo HTML5)

La segunda indica el efecto hover y puede ser cualquiera de estos valores: normal, popout, sliceDown, sliceDownLeft, sliceUp, sliceUpLeft, sliceUpRandom, sliceUpDown, sliceUpDownLeft, fold, foldLeft, boxRandom, boxRain, boxRainReverse, boxRainGrow, boxRainGrowReverse.

Además, hay opciones extras que permiten controlar los detalles como la opacidad, velocidad, colores, márgenes y la manera en que serán tratados los textos pero, todo eso queda para que experimenten.

El resultado final podría ser algo como esto:

Wednesday, July 24, 2019

Una forma sencilla de desplazarse con jQuery

Este sería un método genérico de agregar la posibilidad de animar el desplazamiento interno ha cualquier parte de una página web. En palabras simples, hacer click en alguna parte y que la página se mueva y nos ubique allí.

Hay muchos plugins de jQuery que lo hacen pero para un uso normal, suelen ser excesivos porque están pensados para adaptarse a situaciones y necesidades diversas y, al final de cuentas, uno siempre los usa de modo bastante más elemental.

¿Cómo hacer esto? Basta saber dos cosas: la posición de la etiqueta donde se hace click y la posición de la etiqueta a donde queremos ir; luego, bastaría usar la propiedad scrollTop para mover la página esa distancia.

Por ejemplo, este enlace nos desplazaría hasta el footer de la página:
<a class="moverse" href="#footer-wrapper">ir al footer</a>
El script es sencillo, asociamos una clase cualquiera (en este caso la llamo moverse) a un evento onclick:
$('.moverse').live('click', function(e) { 
// con esto, impedimos que se ejecute (más información)
e.preventDefault();
// leemos el atributo href de la etiqueta que es el ID a donde queremos ir
var adonde = $(this).attr('href');
// guardamos su posición en la página (más información)
var posicion_donde = $(adonde).offset();
// y calculamos la distancia entre donde estamos y donde queremos ir
var distancia = posicion_donde.top;
// por último, nos movemoss usando una animación (más información)
$('body,html').animate({scrollTop: distancia}, 500);
});
<a class="moverse" href="#outer-wrapper">ir al inicio de la página</a>

Wednesday, June 26, 2019

Mostrar feeds de cualquier sitio con jQuery

FeedEkes un plugin para jQuery que nos facilita la tarea a la hora de mostrar contenido de sitios externos a través de sus feeds; tanto de nuestro sitio como de cualquier otro..

En la página de los desarrolladores podemos descargar el archivo RAR que contiene un ejemplo completo y del que sólo necesitamos el archivo FeedEk.js que alojamos en un servidor, incluimos en la plantilla o agregamos a un elemento HTML:
<script type="text/javascript" src="URL_FeedEk.js"></script>
Luego, donde quisiéramos que se mostrase el contenido, pondríamos un DIV vacío de este modo:
<div id="divRss"></div>
Lo único que nos faltaría es ejecutar la función:
<script type="text/javascript">
$(document).ready(function(){
$('#divRss').FeedEk({
FeedUrl : 'URL_FEED',
MaxCount : 3,
ShowDesc : true,
ShowPubDate: true
});
});
</script>
donde tenemos una serie de opciones a elegir:
MaxCount es la cantidad de entradas a mostrar (por defecto 5)
ShowDesc permite mostrar u ocultar el contenido (por defecto true)
ShowPubDate permite mostrar u ocultar la fecha de publicación (por defecto true)

El único dato obligatorio s la URL del feed a mostrar que colocaremos en FeedUrl y que puede ser casi cualquiera; sólo es cosa de probar y ver:

http://miblog.blogspot.com/feeds/posts/default
http://miblog.com/feeds/posts/default
http://feeds2.feedburner.com/miblog
http://miblog.com/feed.php

Obviamente, el estilo con que se mostrarán puede ser personalizado. Para comenzar, pueden usarse algunas de las reglas que se inlcuyen en el archivo FeedEk.css que son bastante sencillas:

#divRss {} es el contenedor general, el DIV donde se mostrará el feed
#divRss .ItemTitle {} es un DIV con el título de cada entrada
#divRss .ItemTitle a {} es el enlace con el título de cada entrada
#divRss .ItemDate {} es un DIV con la fecha
#divRss .ItemContent {} es un DIV con el contenido

Detalles extras que dependerán del contenido pueden ser configuradas por separado:

#divRss .ItemContent p {}
#divRss .ItemContent img {}

Wednesday, June 12, 2019

Fechas relativas con jQuery

Timeago es un plugin para jQuery que pemite transfrormar una fecha "normal" en una fecha relativa, es decir, calcular cuanto tiempo ha pasado desde ese momento hasta ahora.

Si bien es algo que también puede hacerse sin librerías, este plugin posee algunas características que lo hacen especial ya que soporta casi cualquier tipo de formato de fecha por lo que se adapta bastante bien a cualquier sistema y para quien quiera ser "cool", utiliza una estructura de microformatos que también interpreta las nuevas etiquetas de HTML5 tales como <time> </time>

Para usarlo, descargamos el script, lo alojamos en un servidor y lo agregamos al head, debajo de la librería jQuery:
<script src="URL_jquery.timeago.js" type="text/javascript"></script>
Si no queremos usar archivos externos, copiamos y pegamos su contenido:
<script type='text/javascript'>
//<![CDATA[
...... acá pegamos el contenido del script jquery.timeago.js .......
//]]>
</script>
El plugin está en inglés pero, podemos cambiarlo, ya sea manualmente, buscando las variables con los textos o bien descargando cualquiera de las extensiones que ya están predefinidas y abarcan un sinnúmero de idiomas. En este caso, simplemente copiamos y pegamos ese código debajo de lo anterior; este sería el español:
<script type='text/javascript'>
//<![CDATA[
...... acá pegamos el contenido del script jquery.timeago.js .......
...... acá pegamos el contenido del script jquery.timeago.es.js .......
//]]>
</script>
Por último, ejecutamos la función indicándole la etiqueta y/o clase que debe analizar una vez que la página esté cargada:
<script type='text/javascript'>
$(document).ready(function(){
$('abbr.published').timeago();
});
</script>
En este caso, utilizo una etiqueta ABBR con la clase published ya que así es como Blogger muestra ese dato por defecto:
<a class='timestamp-link' expr:href='data:post.url' itemprop='url' rel='bookmark' title='permanent link'>
<abbr class='published' expr:title='data:post.timestampISO8601' itemprop='datePublished'>
<data:post.timestamp/>
</abbr>
</a>
Claro que, si la plantilla está muy personalizada, es posible que ese código sea distinto; sea el que sea, debe buscarse cualquiera de las variables que usa Blogger para mostrar la fecha de las entradas: data:post.timestamp o data:post.timestampISO8601 y re-armar la etiqueta; por ejemplo, de este otro modo:
<span class='timeago' expr:title='data:post.timestampISO8601'><data:post.timestamp/></span>
en cuyo caso, el script se llamaría de este modo:
$('span.timeago').timeago();
¿Y la fecha de los comentarios?

Sería similar, bastaría buscar el dato de Blogger: data:comment.timestamp y modificarlo pero ... en este momento, conviven muchos tipos de códigos para comentarios lo que hace engorroso enumerar cada uno de ellos así que sólo mostraré la forma de hacerlo con los nuevos comentarios anidados que es el método que podría causar más problemas ya que todo es generado por un script interno del sistema.

En este caso, lo que el script de Blogger escribirá será algo así:
<span class="datetime secondary-text">
<a href="URL_COMENTARIO" rel="nofollow"> LA FECHA </a>
</span>
y no tenemos forma de modificar ese código, lo que haremos es modificar una línea del script para que lea ese dato. Buscamos:
var iso8601 = $t.isTime(elem) ? $(elem).attr("datetime") : $(elem).attr("title");
y lo cambiamos por:
var iso8601 =  $(elem).text()
y llamaremos a la función de este modo:
$(document).ready(function(){
$('span.datetime a').timeago();
});
Pero, para que esto funcione correctamente, debemos asegurarnos que el formato de la fecha de los comentarios sea adecuada así que en Configuración | Comentarios | Formato de hora de los comentarios, indicamos esto:

Wednesday, May 8, 2019

Slider Kit: Un plugin multifuncional para jQuery

Este plugin para jQuery es imposible de explicar detalladamente porque posee tal cantidad de opciones que resulta imposible enumerarlas. Se trata de Slider Kit y lo podemos descargar desde lo descargamos desde Google Codes.

Su característica principal es que el plugin reune en si mismo una serie de características que normalmente requieren el uso de varios scripts; genera slideshows, galerías de distinto tipo, carruseles de imágenes, pestañas, sliders de contenido, etc; y todo eso lo hace de manera modular, con un CSS básico que podemos personalizar a gusto y agregando características avanzadas tales como el control de los elementos con la rueda del ratón y animaciones de diferente tipo.

Aunque no lo he probado en todos los navegadores, dicen que funciona en todos, incluyendo Internet Explorer 8.

Como cualquier otro de estos scripts, debemos agregar los archivos antes de </head> ya sea con archivos externos o copaindo su contenido en la plantilla misma:
<script src='http://ajax.googleapis.com/ajax/libs/jquery/1/jquery.js' type='text/javascript' />
<script type="text/javascript" src="URL_jquery.sliderkit.1.4.min.js />
<script src='URL_jquery.easing.1.3.js' type='text/javascript />
<script type="text/javascript" src="URL_jquery.mousewheel.min.js />
Luego, dependiendo de qué queremos utilizar, llamamos a las funciones; por ejemplo:
<script type="text/javascript">
jQuery(window).load(function(){
jQuery(".newslider-vertical").sliderkit({shownavitems:3,verticalnav:true,navitemshover:true});
jQuery(".tabs-standard").sliderkit({auto:false,tabs:true,mousewheel:true,circular:true,panelfx:"none"});
// agregamos todas las funciones que vayamos a necesitar
});
</script>
y por último, el CSS, que, tal como dije antes, podemos personalizar aunque para empezar, conviene que utilicemos las reglas de estilo por defecto y luego, ir probando.


La descarga incluye mucha información detallada y ejemplos así que es una buena opción para simplificar scripts ya que la forma de armar los contenidos es muy similar y cuando se entiende su funcionamiento, termina siendo sencillo generar cosas diferentes, sin restricciones en cuanto a la cantidad que pueden ser agregadas en una misma página.

Tuesday, April 23, 2019

TWITTER APLICACION

Twitter Follow Box es un plugin para jQuery que nos permite agregar un gadget de Twitter que copia el estilo del plugin Lilke Box de Facebook. Es fácil de integrar a cualquier sitio y posee varias opciones que permiten adaptarlo a nuestros gustos personales.

Descargamos el ZIP que ofrecen en al página de los desarrolladores y allí nos encontraremos con cuatro archivos:

followbox.css son las reglas de estilo; podemos copiar su contenido y agregarlo en la plantilla o un elemento elemento HTML colocándolo entre etiquetas <style> y </style>; obviamente, podemos modificarlo aunque así como está, funcionará perfectamente

jquery.followbox.js es el plugin en si mismo, podemos usar ese archivo o su versión minimizada llamada jquery.followbox.min.js; cualquier a de ellos, lo alojamos en un servidor externo o lo agregamos antes de </head>, copiando y pegando el contenido del archivo:
<script type='text/javascript'>
//<![CDATA[
  ... acá pegamos el contenido del archivo ...
//]]>
</script>
Por último, deberíamos cambiar la URL de un pequeño ícono que se utiliza en el gadget; la imagen llamada icon_twitter.png que alojamos donde nos plazca y luego, buscamos esto en el script:
var d="followbox/icon_twitter.png";
y lo cambiamos por la dirección URL de nuestra imagen.
var d="http://mi_imagen.png";
Con eso, ya estamos listos para mostrarlo donde se nos ocurra. Por ejemplo, si agregamos un elemento HTML en la sidear, allí, escribimos lo siguiente:
<div id="MIfollowbox"></div>
<script>
  $('#MIfollowbox').followbox({
    'user' : 'NOMBRE_USUARIO'
  });
</script>
Y eso es todo. Es un DIV vacío, al que le damos un ID único (en este ejemplo lo llamo MIfollowbox) y la llamada a función donde sólo es necesario colocar nuestro nombre de usuario en Twitter.

Como decía, una serie de opciones extras permiten configurar algunos detalles:

width es el ancho en pixeles
height es el alto en pixeles
border_color el color del borde
bg_color el color del fondo
bg_image una imagen de fondo optativa
title_color el color del texto del título
total_count_color el color indicando la cantidad de seguidores
follower_name_color el color de los enlaces a los seguidores
theme permite seleccionar un estilo global; puede ser light, dark o custom

Todas ellas son optativas y se agregan en el mismo script, separándolas con comas:
$('#MIfollowbox').followbox({
  'user' : 'NOMBRE_USUARIO',
  'theme' : 'dark'
});

Friday, April 19, 2019

jQuery 2.0: IE8 y cómo resolver problemas

Hace pocos meses, comentaba sobre las actualizaciones de la librería jQuery y de los recaudos que había que tomar si los implementábamos. Ahora, que ya está disponible la versión 2, todo lo dicho en ese momento sigue siendo válido pero, le debemos agregar un punto extra: la nueva librería NO es compatible con las versiones de Internet Explrorer anteriores a la 9.

Esto, no significa que funcionará mal significa que directamente: NO FUNCIONARÁ en IE8 por ejemplo porque los desarrolladores han dejado de dar soporte a ese navegador, ahorrando, de este modo, decenas de líneas de código.

¿Qué debemos tener en cuenta si es que utilizamos esta librería?

Primero que nada, sólo necesitamos una; es muy común ver que se cargan varias versiones porque se copian los códigos tal como se muestran en las páginas de ejemplo sin tener en cuenta que, cualquier cosa que agreguemos o querramos probar, debe pasar por el filtro del sentido común y tratar de entender qué estamos haciendo.

Por otro lado, si bien es fácil agregar la librería con algo así:

<script src='http://code.jquery.com/jquery-latest.js' type='text/javascript'/>

Esto, cargará siempre la última versión con lo cual, ciertas cosas que antes funcionaban, pueden dejar de funcionar.

La nueva versión ya está disponible en los repositorios de Google así que podemos usarla cambiando el número:

<script src='//ajax.googleapis.com/ajax/libs/jquery/2.0.0/jquery.min.js' type='text/javascript'/>

Ahora bien ¿Y que hacemos con IE8? Recuerden que jQuery 2 no funcionará en ese navegador.

Una alternativa es aprovecharse de los condicionales que inventó Microsoft para lidiar con estas cosas. Hay varios sitios que hablan sobre l tema e incluso el mismo blog de jQuery propone una alternativa pero, es completamente errónea así que, acá está la solución tal como define Impresive Webs y que funciona de manera correcta aunque el código parezca un poco absurdo.

<!--[if lt IE 9]>
<script src='//ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js' type='text/javascript'/>
<![endif]-->

<!--[if (gte IE 9) | (!IE)]><!-->
<script src='//ajax.googleapis.com/ajax/libs/jquery/2.0.0/jquery.min.js' type='text/javascript'/>
<!--<![endif]-->

Lo que hará eso es cargar la versión 1.9.1. en Internet Explorer 8 o inferior y la versión 2 en cualquier otro navegador.

Si quieren verificarlo, el código está colocado tal cual en este mismo blog.

Monday, April 15, 2019

jFontSize: Manejar el tamaño de los textos

Hay muchos scripts que hacen lo mismo que jFontSize pero este es bastante simple ya que usa la librería jQuery.

En general, no creo que sea algo demasiado útil ya que hacer zoom es algo que cualquier navegador admite de modo nativo pero, aún así, muchos sitios lo utilizan así que no hay nada de malo en tenerlo como opción. La idea es facilitar la generación de botones que permitan aumentar o disminuir el tamaño de las fuentes de los textos.

El script es muy pequeño y puede descargarse desde la web del desarrollador aunque lo que ahí nos ofrecen no admiten las opciones que posee el plugin (es raro pero es así) entonces, lo mejor, es descargar el zip con los scripts y los ejemplos. Allí, en la carpeta JS, veremos el archivo que necesitamos: jquery.jfontsize-1.0.js

Una vez agregado a nuestro sitio, antes de </head> deberíamos establecer las reglas de estilo de esos botones. En este caso, puse lo siguiente pero, puede ser cualquier otra cosa:
<style>
.jfontsize-button {
background-color: #EEE;
border-radius: 4px;
box-shadow: 0 0 0.2em #888 inset;
color: #000;
cursor: pointer;
display: inline-block;
font-family: Arial;
font-size: 13px;
font-weight: bold;
margin: 0 1px;
opacity: 0.8;
padding: 0.3em 0;
text-align: center;
text-decoration: none;
width: 2em;
}
.jfontsize-button:hover {
opacity: 1;
}
.jfontsize-disabled, .jfontsize-disabled:hover {
opacity: .5;
pointer-events: none;
}
<style>
Y de manera genérica, lo ejecutamos de este modo:
$(document).ready(function() {
$('#nombreID').jfontsize();
// o bien esto otro si queremos hacer referencia a la clase
$('.nombreCLASE').jfontsize();
})
Donde nombreID o nombreCLASE deben indicar la etiqueta sobre la que funcionará, teneindo en cuenta que esa etiqueta debe tener una regla de estilo con un tamaño de fuente ya sea específico o heredada de su contenedor. Por ejemplo, si quisiéramos aplicarlo a todas las entradas de este blog, debería usar algo así:
$('.post-body').jfontsize();
ya que los textos se encuentran en un DIV con esa clase sin embargo, si dentro de esa etiqueta, hay otras que especifican un tamaño, estas no se verán afectadas; veamos un ejemplo concreto:
<div id="demojfontsize">
<div style="text-align:right;">
<a id="jf1-b1" class="jfontsize-button" href="#">A-</a>
<a id="jf1-b2" class="jfontsize-button" href="#">A</a>
<a id="jf1-b3" class="jfontsize-button" href="#">A+</a>
</div>
... un texto cualquiera ...
<span style="color:#FF0; font-family:cursive; font-size:20px;">otra fuente y otro tamaño</span>
... un texto cualquiera ...
</div>
si el script lo ejecutamos así:
$('#demojfontsize').jfontsize({
btnMinusClasseId: '#jf1-b1',
btnDefaultClasseId: '#jf1-b2',
btnPlusClasseId: '#jf1-b3'
});

Los botones A- y A+ aumentarán o disminuirán el tamaño del texto y el botón A central restaurará el tamaño a su valor original pero, nada de eso afectaría el span de color amarillo ya que en la etiqueta, el tamaño del texto es explícito porque se encuentra en un atributo style o está definido en alguna otra regla.

La cantidad de clicks sobre los botones es infinita así que llegará un momento en que el tamaño sea gigantesco o no se vea nada. Eso es algo que podemos controlar con las opciones:

btnMinusMaxHits es un valor (por defecto 10) que establece la cantidad de veces que puede decrementarse el tamaño
btnPlusMaxHits es un valor (por defecto 10) que establece la cantidad de veces que puede incrementarse el tamaño
sizeChange es un valor que establece cuanto aumenta o disminuye y por defecto es 1y está expresado en pixeles

Si el script dijera esto:
$('#demojfontsize2').jfontsize({
btnMinusClasseId: '#jf2-b1',
btnDefaultClasseId: '#jf2-b2',
btnPlusClasseId: '#jf2-b3',
btnMinusMaxHits: 5,
btnPlusMaxHits: 5,
sizeChange: 1
});
Habría un máximo de cinco clicks disponibles y al llegar a ese límite, el botón se deshabilitaría.


Para usarlo en distintas etiquetas de la misma página, debemos indicar al script, el ID o la clase de los botones que es lo que hacemos con estas opciones:

btnMinusClasseId es el ID o clase del botón decrementar
btnDeafultClasseId es el ID o clase del botón incrementar
btnPlusClasseId es el ID o clase del botón restaurar

Wednesday, February 13, 2019

Stratus: Un plugin de JQuery para SoundCloud

Stratus es un plugin que requiere jQuery y nos permite agregar una barra de reproducción que se conecta con una cuenta cualquiera de SoundCloud, con una lista de reproducción, grupos o archivos individuales.

Se puede incluir fácilmente en cualquier sitio incluso Blogger ya que es un script que podemos colocar en cualquier parte, ya sea la plantilla, una entrada o una página estática:
<script type="text/javascript" src="http://stratus.sc/stratus.js"></script>
Al cual debemos configurar indicando la url con la dirección que queremos cargar:
<script type="text/javascript">
$(document).ready(function(){
$.stratus({links: 'https://soundcloud.com/nathan-arnone/sets/r-e-m-green'});
});
</script>
En este ejemplo, es un set (una lista de reproducción) pero podría ser la cuenta de un usuario y reproducir los temas de manear aleatoria de este modo:
$stratus({
links: 'http://soundcloud.com/nombre',
random: true
});
Tiene más opciones y todas se agregan del mismo modo:

align indica dónde aparecerá la barra; por defecto es bottom pero puede usarse top si se queire mostrar arriba
animate es el efecto gráfico, puede ser slide (es el valor por defecto), fade, o false si no se quiere ninguno
auto_play puede ponerse a true si queremos que comience a reproducirse automa´ticamente
buying muestra (true) u oculta el botón de comprar
color define el color de los controles y por defecto es F60
download muestra (true) u oculta el botón de descargar
links es la url a reproducir, si se quieren poner temas sueltos, se separan con comas
offset es la separación dela barra con respecto al borde
position define la posición, si quedará fija (fixed) que es el valor por defecto o no (scroll)
random si es true los temas se reproducirán de manera aleatoria
stats muestra (true) u oculta el botón de estadísticas y detalles
theme permite establecer un estilo especial indicando la url del archivo CSS
user muestra (true) u oculta el botón de información
volume es el volumen y es un valor entre 0 y 100 (por defecto es 50)


Monday, February 4, 2019

25 plugins para crear sliders con jQuery

Una selección de plugins que utilizan la librería jQuery para crear galerías de imágenes, sliders y slideshows.

De todo un poco como en botica.