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

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>

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(); });

Monday, December 16, 2019

Espejito espejito

La publicidad dice que el Cybertecture® Mirror es un espejo programable ... también dice más cosas, habla de lo digital, de lo útil que es tener uno en la casa, la oficina, la cartera de la dama o el bolsillo del caballero, que viene en varios colores y en varios idiomas ... un espejo multilingue.

Si ya los convencí para salir a comprar uno, refrenen sus ansias porque no es nada barato; algunos hablan de siete mil y otros de ocho mil dólares ... bueno, si alguien quiere aprovechar las fiestas y ponerlo en el arbolito, seguramente es un regalo mucho más atractivo que esa corbata en la que estaba pensando o ese cacharrito de cerámica que terminará adornando el fondo del placard hasta que se rompa y pase a mejor vida.


Usando un control remoto o con un opcional touch screen, interactua con los usuarios, mostrando información, chequeando el estado de salud con un sensor (no indica donde se coloca), comunicándose con la computadora, los teléfonos móviles y cualquier otro artefacto digital y además, se nos crea nuestra propia página web desde donde podemos establecer preferencias o dejar mensajes a la familia.

¿Tendrá memoria y nos mostrará eso que fuimos? ¿Será realmente un adelanto tecnológico que nos permitirá ver lo que queremos ser o sólo nos mostrará eso que somos? ¿Cuando funcione mal nos mostrará todo eso que jamás pudimos ser?

Demasiadas preguntas. Me parece que ni el espejo de la bruja de Blancanieves podría responderlas.


Thursday, December 12, 2019

Tooltips con CSS: Más simple, imposible

Hay muchas formas de crear tooltips con CSS; probablemente, esta, que muestra webdesignerdepot.com es una de las más sencillas que existen ya que sólo se requiere establecer una clase en el enlace o etiqueta a la cuál queremos aplicarlas y poner las dos reglas de estilo.

En este caso, la clase la llamamos tooltip pero, puede ser cualquier otro nombre y funcionará en cualquier navegador que admita el uso de los pseudo-elementos :after y :before.

El formato gráfico es completamente configurable así que las variaciones pueden ser casi infinitas.
<style type="text/css">
.tooltip {
display: inline;
position: relative;
}
.tooltip:hover:after {
bottom: 26px;
content: attr(title); /* este es el texto que será mostrado */
left: 20%;
position: absolute;
z-index: 98;
/* el formato gráfico */
background: rgba(255,255,255, 0.2); /* el color de fondo */
border-radius: 5px;
color: #FFF; /* el color del texto */
font-family: Georgia;
font-size: 12px;
padding: 5px 15px;
text-align: center;
text-shadow: 1px 1px 1px #000;
width: 150px;
}
.tooltip:hover:before {
bottom: 20px;
content: "";
left: 50%;
position: absolute;
z-index: 99;
/* el triángulo inferior */
border: solid;
border-color: rgba(255,255,255, 0.2) transparent;
border-width: 6px 6px 0 6px;
}
</style>
Y se usaría así:
<a href="#" title="este es un ejemplo de tooltip sencillo" class="tooltip">un ejemplo</a>

El texto que se mostrará es el que se encuentra en el atributo title de la etiqueta; si se quisiera utilizar otro atributo, bastaría cambiar la propiedad content; por ejemplo si se quiere usar rel o href sería:
content: attr(rel);
content: attr(href);
Hay que tener en cuenta que, dada su sencillez, el tooltip se verá "cortado" cuando se queire mostrar en algo que está muy a la derecha si el contenedor donde se encuentra la etiqueta tiene la propiedad overflow: hidden; algo bastante común en muchas plantillas de Blogger.

Monday, December 9, 2019

El NO misterio de posición absoluta

Cuando diseñamos una página web o simplemente agregamos etiquetas, estas se acomodan de manera natural, ya sea una al lado de la otra o bien una debajo de la otra, dependiendo del tipo que sean. El contenido fluye naturalmente, de arriba hacia abajo y de izquierda a derecha, tal como ocurre cuando escribimos o leemos.

Para modificar esa secuencia usamos distintas propiedades de CSS; les colocamos márgenes, cambiamos su tipo con display o las hacemos flotar.

De un tiempo a esta parte, se está empleando una nueva forma de posicionar "cosas" en la página, utilizando para ello la propiedad respectiva que se llama position y, que como toda propiedad de CSS, tiene un valor por defecto aunque no la definamos. Toda etiqueta tiene el valor static que no hace nada salvo decirle al navegador que esa etiqueta es "normal".

Las variantes que admite esa propiedad son tres: fixed, relative y absolute. Justamente, el uso de esta última es la que últimamente se está extendiendo porque es una forma bastante sencilla de ubicar elementos con cierta precisión pero, se suele ver que se usa de manera extraña o mejor dicho, sin tener en cuenta qué es o que hace y por lo tanto, cómo afecta al resto de las etiquetas.

Lo primero que debe tenerse en claro es que ´lo absoluto no existe y que toda posición absoluta es relativa a algo; ¿a qué? a la etiqueta que la contiene, sea la que sea ya que una página web no es otra cosa que un montón de etiquetas contenidas en otras etiquetas hasta llegar a la primera que es el body.

De este modo, si colocamos position:absolute; en una etiqueta cualquiera, el navegador la posicionará buscando "hacia atrás" la primera etiqueta que no tenga la propiedad position:static; y si no hay ninguna, tomará como referencia el body, es decir, la esquina superior izquierda de la ventana.

Este es el error más común, suponer que si algo tiene una posición absoluta, el navegador entenderá dónde queremos que se vea pero, los navegadores no piensan, sólo obedecen ordenes.

Tampoco es cierto que agregando esa propiedad, todo se resuelva porque por si sola no causa mayor efecto; en este ejemplo, el contenedor es "normal" y el contenido es absoluto y sin embargo, todo se muestra como si esta no existiera, el rectángulo se ve debajo el texto:

#contenedor {position:static;}
#contenido {position:absolute;}

Para que tenga algún efecto, debemos establecer también algunas de las propiedades que definen esa posición (left, top, right, bottom) ya que si no lo hacemos, esas propiedades son calculadas automáticamente; en el ejemplo anterior, el navegador me dice que left: es 67 y top es 414 aunque yo no lo haya escrito; si le digo que los coloque en cero, el rectángulo se moverá hasta colocarse en el ángulo superior izquierdo del primer contenedor que no tenga la propiedad position:static (que sea relative, absolute o fixed) que en el caso de esta entrada, es el DIV #main-wrapper:


Justamente, el poder usar left, top, right y bottom para ubicar algo, es lo que hace de esta propiedad una forma sencilla de diseñar algo pero, si podemos posicionar un objeto de ese modo ¿para que agregar otras propiedades como margin y float?

Esto también es bastante común y debería evitarse. Si posicionamos algo de modo absoluto, los márgenes suelen ser innecesarios y las flotaciones, inútiles; esto:
#contenido {
float: right;
margin-right: 20px;

right: 20px;
top: 40px;
}
se puede simplificar y la regla sólo debería decir:
#contenido {
right: 20px;
top: 40px;
}
Veremos lo mismo asi que ¿para qué complicarse la vida?


Lo mismo puede decirse se display; salvo muy raras excepciones, es innecesario agregar esa propiedad en la regla.

Por supuesto, como la posición es absoluta, margin: 0 auto; no centra absolutamente nada; mucho menos lo hará text-align o el viejo atributo align. Si queremos centrar algo que tenga este tipo de propiedad, debemos conocer su ancho. Por ejemplo, en este caso, el rectángulo celeste tiene 200 pixeles de ancho y lo centramos usando left y un margen izquierdo negativo:
#contenido {
left: 50%;
margin-left: -100px;
margin-top: -60px;
position: absolute;
top: 50%;
}
Y con top lo podemos centrar verticalmente así que si el contenido es de 200x120, esto, lo centraría en ambos sentidos:
#contenido {
left: 50%;
margin-left: -100px;
margin-top: -60px;
position: absolute;
top: 50%;
}


Wednesday, December 4, 2019

Blogger: Resúmenes tipo mosaico

Cuando se quieren mostrar las entradas resumidas en un formato tipo mosaico y que las imágenes que generalmente se utilizan como adorno, mantengan su proporción, estamos hablando de una estructura distinta a la clásica que muestra una serie de rectángulos donde la altura es siempre fija:


Es el caso del famoso Pinterest o sitios similares que van colocando rectángulos de altura variable, acomodándolos una debajo del otro, llenando los espacios vacíos.


Para que sea simple de hacer, ese tipo de estructura requiere CSS3 y utilizar las distintas variantes de la propiedad column lo que implica que sólo será visible en navegadores de última generación. Para colmo, a mi entender, ese sistema no es muy razonable en un blog ya que las columnas se escriben de arriba hacia abajo con lo que, si colocáramos 15 entradas en tres columnas, la columna izquierda tendría las primera 5, la del centro las segundas 5 y la tercera el resto; algo que puede ser molesto ya que un lee e interpreta de izquierda a derecha.

Otra forma de hacer lo mismo es usar scripts o plugins específicos aunque algunos de ellos no solucionan esos problemas ya que la única manera de hacer algo así y que se vea en cualquier navegador es mediante alguna clase de script que calcule alturas y vaya "dibujando cada rectangulito estableciendo propiedades absolutas.

Ahora bien, si uno no quiere complicarse la vida, en Blogger, habría una solución simple que no requiere nada sofisticado y que debería funcionar en cualquier navegador ya que no se necesitan propiedades especiales y el script es similar a cualquier otro que lea los feeds del sitio utilizando json.

La idea es crear tres DIVs que serán las columnas, uno flota a la izquierda, otro a la derecha y el tercero está centrado. Luego, vamos agregando las entradas a cada una de ellos en el orden en que las leemos de tal manera que si mostramos 15 entradas, los post 1,4,7,10 y 13 estarán en DIV izquierdo, los posts 2,5,8,11,14 en el centro y los posts 3,6,9,12,15 en el DIV derecho.

Voy hacer lo con un ejemplo concreto; busqué el includable principal del blog:
<b:includable id='main' var='top'>
.......
</b:includable>
Y como es algo que sólo quiero mostrar en el home sin hacer una plantilla nueva, me limitaré a condicionar su contenido y agregar las nuevas columnas de este modo:

<b:includable id='main' var='top'>
<b:if cond='data:blog.url == data:blog.homepageUrl'>
<div id='left-col'/>
<div id='right-col'/>
<div style='clear:both;'/>
<script src='/feeds/posts/default?start-index=1&amp;max-results=12&amp;orderby=published&amp;alt=json-in-script&amp;callback=mosaicocols' type='text/javascript'/>
<b:else/>
<!-- AQUÍ DEJO TODO LO QUE TENGA, SEA LO QUE SEA -->
</b:if>
</b:includable>
Y ahora, el script que es el que interpreta los feeds; lo coloco antes de </head> y usa jQuery para simplificar las cosas pero, podría hacerse con cualquier otra librería o con ninguna:
<b:if cond='data:blog.url == data:blog.homepageUrl'>
<script type='text/javascript'>
//<![CDATA[
function mosaicocols(json) {
var entry, posttitle,posturl,postimg;
var salida = "";
var contar = 0;
for (var i = 0; i < 24; i++) { // voy a mostrar 24 entradas
if (i == json.feed.entry.length) { break; }
entry = json.feed.entry[i]; // el feed
posttitle = entry.title.$t;; // el título de cada post
for (var k = 0; k < entry.link.length; k++) {
if (entry.link[k].rel == 'alternate') {
posturl = entry.link[k].href; // la dirección url de cada post
break;
}
}
// buscamos una imagen para decorar
var t = "";
if ("media$thumbnail" in entry) {
postimg = entry.media$thumbnail.url; // es la que Blogger detecta
postimg = postimg .replace('s72-c','s275'); // pero la cambio para que sea más grande y no una miniatura
} else {
// si no se detecta una, buscamos en el mismo post
var s, a, b, c, d;
s = entry.content.$t;
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!="")) {
postimg = d; // es la primera imagen del post
} else {
// y si no hay ninguna, usamos una imagen genérica
postimg = 'url_imagenxdefecto';
}
}
// ahora, armo la salida de cada rectángulo utiilizando cualquier estructurura HTML que se me ocurra
salida = "<div class='m-post' id='"+i+"'>";
salida += "<a class='miniatura' href='" + posturl + "' target='_blank'><img src='" + postimg + "' /></a>";
salida += "<h2><a href='" + posturl + "' target='_blank'>" + posttitle + "</a></h2>";
salida += "</div>";
contar = contar+1; // para simplificar las cosas, voy contando los posts
if (contar==1) { // posts 0 3 6 9 12 15 etc
$('#left-col').append(salida); // los agrego a la columna izquierda
} else if (contar == 2) { // posts 1 4 7 10 13 16 etc
$('#right-col').append(salida); // los agrego a la columna derecha
} else { // posts 2 5 8 11 14 17 etc
$('#center-col').append(salida); // los agrego a la columna central
contar = 0; cada tres, pongo el contador a cero
}
}
}
//]]>
</script>
</b:if>
Estas son las tres líneas que deberían cambiarse si se usa otra librería o si no se usa ninguna:
$('#left-col').append(salida);
$('#right-col').append(salida);
$('#center-col').append(salida);
Por último, el CSS que también va antes de </head>:
<b:if cond='data:blog.url == data:blog.homepageUrl'>
<style>
// si es necesario, agrego cualquier cosa que se necesaria para cambiar anchos u ocultar elementos
#outer-wrapper, #content-wrapper, #header-wrapper, #main-wrapper {width:930px;}
#sidebar-wrapper {display:none;}
// estas serían las reglas de las tres columnas
#left-col {float:left;}
#right-col {float:right;}
#center-col {margin:0 auto;width: 297px;}
// cada uno de los rectángulos
.m-post {
border: 1px solid #EEE;
margin-bottom: 20px;
padding: 10px;
text-align: center;
width: 275px;
background-color: #FFF;
box-shadow: 0 5px 5px #AAA;
position: relative;
}
.m-post a {text-decoration:none;}
// la imagen de los posts
.m-post .miniatura {
display: inline-block;
}
.m-post .miniatura img {
vertical-align: top;
width: 275px;
}
// el título de los posts
.m-post h2 a {
color:#666;
font-size: 17px;
font-family: Tahoma;
font-weight: normal;
letter-spacing: 0;
padding: 0;
text-transform: none;
}
</style>
</b:if>
Y eso es todo. Obviamente, de ahí en adelante, cualquier cosa es posible y cada uno deberá investigar y jugar un poco.

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>