0

Resumen de dudas sobre JavaScript

Como son preguntas que se repiten una y otra vez, esta entrada trata de responder las más frecuentes referidas al tema de utilizar scripts en Blogger. Ya no se trata sólo de alojar los archivos sino, de usarlos correctamente.

Insisto, insisto, insisto: Lo mejor es agregarlos a la plantilla y utilizar la menor cantidad de archivos externos. De todas formas, la sintaxis correcta para agregar un script contenido en un archivo externo es la siguiente:
<script src='URL_archivo.js' type='text/javascript'></script>
¿Por qué es la correcta? Porque eso dicen las reglas diablo2 establecidas por la w3.org. Estas, indican que no puede haber etiquetas que no tengan su correspondiente etiqueta de cierre. Sin embargo, pese a que Blogger se supone que sigue reglas estrictas en su plantilla y nos vuelve locos cambiando cosas a su antojo, no parece haber leido esta así que si escribimos eso, al guardarlo, veremos esto:
<script src='URL_archivo.js' type='text/javascript'/>
En la práctica, salvo que a alguien se le ocurra intentar validar su código (algo absurdo en Blogger) no tiene mayor importancia.

La extensión de esos archivos es .js pero eso, sólo es una convención, en realidad, puede ser cualquier otra o no tener ninguna en absoluto, basta que sea un archivo de texto plano sin formato y que el contenido sea un código válido y no contenga etiquetas HTML.

El atributo type es obligatorio y el atributo language que muchas veces se ve es innecesario a menos que el lenguaje del archivo no sea JavaScript. Eventualmente, se agrega un atriburto charset si el script contiene caracteres especiales:
<script src='URL_archivo.js' type='text/javascript' charset='utf-8' />
Por lo general, se ubican en el HEAD de la página, es decir, antes de la etiqueta </head> porque ese es el lugar donde nos aseguramos que funcionen. Esto, provoca que, al cargarse la página, se produzca una demora ya que el navegador debe acceder a esos archivos, leerlos y ejecutarlos. Mientras eso ocurre, el resto de los procesos de carga se detiene. No hay una regla fija que nos permita decir que todos los scripts deben ubicarse en tal o cual lugar de nuestra plantilla, depende de qué hagan, si no se está seguro de eso, mejor seguir las indicaciones de quienes los han desarrollado o probado.

Muchos de ellos DEBEN ser incluidos en el HEAD porque deben ser ejecutados de manera inmediata pero, esto no ocurre siempre. Algunos, DEBEN ser ejecutados después que la pagina ha sido cargada y para eso existen instrucciones específicas:
<script type='text/javascript'>
window.onload=function() {
// esto se ejecutará cuando la pagina haya termiando de cargarse
}
</script>
Si el script posee instrucciones que modifican la página como innerHTML o appendChild, algunas versiones de Internet Explorer pueden generar un error "Internet Explorer no puede abrir el sitio de http://xxxxxxx. Operación anulada." así que, si debemos utilizarlas, hay que verificar que se ejecuten DESPUÉS que se ha cargado la página (más información). Este error, bastante común ha sido solucionado en IE8.

Una regla elemental es la siguiente: No podemos ejecutar un script que modifique nuestra página si eso que vamos a modificar aún no se ha creado.

Una página web se crea de manera secuencial, línea por línea tal cual se ve en el código fuente así que debemos estar atentos a ese orden. Por ejemplo:
<script type='text/javascript'> getElementById('ejemplo').style.display='none'; </script>
<div id='ejemplo'> ....... </div>
Es un error ya que el DIV llamado ejemplo se crea DESPUES del script y cuando este se ejecuta, aún no existe. El error generado dirá algo así: "getElementById is not defined" o "se esperaba un objeto".

Esto sería lo correcto:
<div id='ejemplo'> ....... </div>
<script type='text/javascript'> getElementById('ejemplo').style.display='none'; </script>
Es el tipo de error que se generará si un script se carga o se ejecuta en algún lugar, de manera equivocada. Por ejemplo es lo que ocurriría si ubicamos mal los scripts de los post relacionados, los emoticones, las diferentes funciones de expandir y contraer, etc. Todas ellas, dejarían de funcionar. Son funciones que se ejecutan al mostrar las entradas así que deben estar ANTES que estas se carguen.

Por el contrario, scripts como los de Twitter y Tumblr es conveniente ubicarlos al final de la página, antes de </body> para que se ejecuten después que la página ha sido cargada y de esa manera, tener el blog funcionando aún cuando los datos de esos servicios no sean accesibles. Sería bueno que Blogger hiciera lo mismo con algunos de sus scripts como los que manejan los comentarios, el buscador o los seguidores.

A diferencia del HTML, el lenguaje JavaScript es sensible a las mayúsculas y minúsculas así que ese detalle debe ser tenido muy en cuenta a la hora de darle nombre a las variables y las funciones.

Aunque hay excepciones, cada línea de código debe terminar con un punto y coma. Es una buena práctica acostumbrarse a hacerlo.

No es usual utilizar esto pero, los scripts externos también pueden cargarse usando código JavaScript; para esto, hay muchos métodos:
<script type='text/javascript'>
window.onload=function(){
if(!document.getElementById || !document.createElement){return;}
var nuevoScript = document.createElement('script');
nuevoScript.type = 'text/javascript';
nuevoScript.src = 'URL_archivo';
document.getElementsByTagName('head')[0].appendChild(nuevoScript);
}
</script>
o bien podemos usar una función:
<script type='text/javascript'>
function loadScript(src) {
nuevoScript = document.createElement( 'script' );
nuevoScript.src = src;
nuevoScript.type = 'text/javascript';
head = document.getElementsByTagName( 'head' )[0];
head.appendChild(nuevoScript);
}
</script>
Una función que usamos así:
<script type='text/javascript'>
loadScript('URL_archivo');
</script>
Para agregar código Javascript válido en las plantillas de Blogger, lo mejor es usar CDATA porque ciertos caracteres como < > & están prohibidos salvo que formen parte del código mismo:
<script type="text/javascript">
//<![CDATA[
....... aquí va el código .......
//]]>
</script>
Si no lo hacemos y el código tiene esos caracteres, pueden aparecer mensajes de error o funcionar mal. Lo mismo ocurrirá con las comillas simples y dobles, los códigos serán cambiados por &#39; y &quot;, provocando errores impredescibles.

Es importante saber que un script puede tener un código que se ejecuta apenas es cargado o bien, una función que se ejecuta sólo cuando la invocamos. Por ejemplo:
<script type='text/javascript'>
alert ('un mensaje');
function ejemploFuncion() {
alert ('otro mensaje');
}
</script>
alert ('un mensaje'); ese ejecutará inmediatamente; en cambio, para que se ejecute alert ('otro mensaje'); debemos llamar a la función:
<script type='text/javascript'> ejemploFuncion(); </script>
Las funciones también puden ser ejecutadas mediante eventos como onclick, onmouseover, etc. Para hacer esto, incluimos esos eventos como atributos de una etiqueta HTML:
<a href='javascript:void(0);' onclick='ejemploFuncion();"> click </a>
Un ejemplo: click

En Blogger, el atributo href es complicado de resolver. Si bien siempre es mejor que tenga un destino real (una dirección) para que funcione aún cuando el visitante tenga JavaScript desactivado, no siempre podemos hacerlo.

Otra forma de llamar a una función es esta:
<a href='javascript:ejemploFuncion();"> click </a>
Otro ejemplo: click

Tampoco es necesario que la etiqueta sea un enlace, pude usarse casi cualquier otra:
<span onclick='javascript:ejemploFuncion();"> click </span>
Un último ejemplo: click

0

Gadgets de imágenes para enlaces.


Ariane
de Templates Novo Blogger tiene un gusto exquisito para diseñar plantillas, por si eso fuera poco también tiene la amabilidad de explicar como podemos conseguir los mismos trucos o efectos que ella aplica en sus plantillas.
Hace unos días nos mostraba la forma de usar gadgets de imágenes para enlazar entradas del blog, aunque también podemos crear enlaces externos consiguiendo un atractivo y funcional menú. Ejemplo de Ariane.
Para los ejemplos se ha utilizado la plantilla Minima de Blogger si nuestra plantilla es distinta se recomienda hacer la prueba en otro blog para evitar posibles errores.

Lo primero que haremos será habilitar el croscoll para añadir nuevos gadgets, buscamos en plantilla Edición de HTML.

<div id='crosscol-wrapper'>
<b:section class='crosscol' id='crosscol' showaddelement='no'/>
</div>
» Donde dice no lo sustituimos por yes

Luego buscamos #outer-wrapper y sustituimos el ancho (width) por 900px.
#outer-wrapper {
width: 900px;

Una vez dimos la anchura suficiente nos situamos justo antes de ]]></b:skin> para añadir los estilos de los nuevos gadgets de imágenes.

#crosscol-wrapper{
margin: 0 auto;
padding: 15px;
float:left;
border:1px solid #2e2e2e; /* color y grosor del borde que rodea el contenido del gadget */
background: #111; /* color de fondo del contenido del gadget*/
}
.crosscol h2{
margin: 0px;
padding: 0px 0px 0px;
text-align:left; /* alineación del título */
height: 25px; /*altura del espacio título */
color: #ccc; /* color de fuente del título */
font-size: 18px; /*tamaño de fuente del título */
font-weight:bold;
text-transform:uppercase;
letter-spacing:-1px;
}
.crosscol .widget{
margin: 0px 2px 0px; /*separación entre los gadgets */
padding: 5px;
width: 200px; /*ancho de cada gadget */
height:220px; /* alto de cada gadget */
float:left; /* flotación a la izquierda (importante)*/
border: 1px solid #2e2e2e; /*color borde de cada gadget*/
background: #212121; /* color fondo de cada gadget */
}
.crosscol .widget img {
margin: 0px;
padding: 0px;
width: 200px; /* ancho de la imagen */
height:160px; /* alto de la imagen */
float:left;
border:1px solid #2e2e2e; /* color borde de imágenes */
}
.crosscol .widget img:hover{
border:1px solid #fa01e6; /* color borde en estado hover */
}
.crosscol .widget-content{
margin: 0px;
padding:3px 0 0; /* distancia entre el texto y la imagen */
color:#ccc; /* color de fuente del texto */
font-size: 97%; /* tamaño fuente del texto*/
text-align:justify; /* alineación del texto */
}
body#layout #crosscol{
margin: 0 auto;
padding: 0 0 0;
width: 900px;
float:left;
}
El siguiente paso será editar un nuevo gadget en el espacio que habilitamos para el crosscol, escogeremos para añadir imagen.



» Donde Título añadiremos el título de nuestro gadget.
» En Pie de foto es el sitio donde añadiremos texto o breve descripción.
» El espacio de Enlace lo utilizaremos para añadir la url del sitio donde seremos dirigidos al clicar sobre la imagen, puede ser una entrada en concreto o cualquier sitio externo.
» El mismo proceso lo repetimos hasta añadir cuatro imágenes.

Guardamos los cambios para no perderlos y esta vez si vamos a marcar para expandir la plantilla de artilugios y buscamos:
<b:section class='crosscol' id='crosscol' showaddelement='yes'>

"A continuación encontraremos 4 veces el siguiente código"

<b:widget id='Image4' locked='false' title='Ejemplo 4' type='Image'>
<b:includable id='main'>
<b:if cond='data:title != &quot;&quot;'>
<h2><data:title/></h2>
</b:if>
<div class='widget-content'>
<b:if cond='data:link != &quot;&quot;'>
<a expr:href='data:link'>
<img expr:alt='data:title' expr:height='data:height' expr:id='data:widget.instanceId + &quot;_img&quot;' expr:src='data:sourceUrl' expr:width='data:width'/>
</a>
<b:else/>
<img expr:alt='data:title' expr:height='data:height' expr:id='data:widget.instanceId + &quot;_img&quot;' expr:src='data:sourceUrl' expr:width='data:width'/>
</b:if>
<br/>
<b:if cond='data:caption != &quot;&quot;'>
<span class='caption'><data:caption/></span>
</b:if>
</div>
<b:include name='quickedit'/>
</b:includable>
</b:widget>

» Los cuatro códigos pertenecen a los cuatro gadgets añadidos, uno por cada imagen.
» En lugar de title='Ejemplo 4' pondría title='título de tu gadget'

Modificaremos cada una de esas cuatro partes de forma que eliminamos lo marcado en color rojo y añadimos lo marcado en color verde.

<b:widget id='Image4' locked='false'title='título de tu gadget' type='Image'>
<b:includable id='main'>
<b:if cond='data:title != &quot;&quot;'>
<a expr:href='data:link'>
<h2><data:title/></h2>
</a>
</b:if>
<div class='widget-content'>
<b:if cond='data:link != &quot;&quot;'>
<a expr:href='data:link'>
<img expr:alt='data:title' expr:height='data:height' expr:id='data:widget.instanceId + &quot;_img&quot;' expr:src='data:sourceUrl' expr:width='data:width'/>
</a>
<b:else/>
<img expr:alt='data:title' expr:height='data:height' expr:id='data:widget.instanceId + &quot;_img&quot;' expr:src='data:sourceUrl' expr:width='data:width'/>
</b:if>
<br/>
<b:if cond='data:caption != &quot;&quot;'>
<a expr:href='data:link'>
<span class='caption'><data:caption/></span>
</a>
</b:if>
</div>
<b:include name='quickedit'/>
</b:includable>
</b:widget>

El resultado de seguir estos pasos podéis verlo haciendo click en la imagen.



0

Tratando de entender el header (3)

El efecto hover sobre el header del blog tal como lo muestra Templates Novo Blogger es realmente muy sencillo de realizar y una excelente idea que Ariane extiende a otros elementos de encabezado como los títulos de las entradas y los de la sidebar. Me voy a limitar a hacer lo mismo sólo en el header y así continuar esta serie para tratar de entenderlo.

El concepto general es siempre el mismo para cualquier cosa y, en realidad, es el mismo para cualquier efecto hover pero, por lo general, estamos a acostumbrados a usarlo sólo en los enlaces:
a {color: #CCCCFF;}
a:hover {color: #FF6666;}
Este efecto de cambiar propiedades CSS cuando colocamos el puntero del ratón encima de algo no está limitado a los enlaces y funciona en cualquier navegador moderno incluyendo IE7 e IE8 así que nada impide aplicarlo a cualquier cosa, incluyendo DIVs.

Aquí, siguiendo la misma idea, lo voy a aplicar sobre el header simplificado que utilizaba en la entrada anterior.

Usando una plantilla mínima, hago algunos cambios en Diseño | Fuentes y Colores y luego, vamos a colocarle una imagen de fondo a todo el blog. Para eso, le agregamo una propiedad al body:
body {
background: #8B9AA9 url(URL_imagenFondo) repeat-x left top;
.......
/* el resto lo dejo como está */
.......
}
Esa imagen es sólo una franja vertical que se repite de izquierda a derecha (repeat-x) y que tiene unos pocos pixeles de altura así que el resto, se rellena con un color de fondo (#8B9AA9).

Ahora, colocaremos una imagen de fondo que sirva como logo. Esta imagen tendrá un ancho equivalente al ancho del blog (es el valor de width) y una altura cualquiera (en este caso, 100 pixeles):
#header-wrapper {
margin: 0 auto 10px; /* está centrado y tiene un pequeño margen que lo separa de los posts */
height: 100px; /* el bloque debemos dimensionarlo con una altura igual a la imagen */
width: 860px; /* y el ancho total que es el ancho del blog */
}
#header-inner {
background: transparent url(URL_imagenLogo) no-repeat left top; /* es la imagen a usar */
height: 100px; /* debemos indicar la altura de esa imagen de fondo */
width: 100%; /* que ocupará todo el ancho del blog */
}
#header a { /* esa imagen es un enlace en las páginas interiores así que le damos los mismo valores */
display: block; /* transformamos el enlace en un rectángulo de cierto tamaño */
height: 100px; /* indicar la altura de la imagen de fondo */
width: 100%; /* indicamos que ocupa todo el ancho */
}
#header-inner:hover { /* es el efecto hover así que ponemos la segunda imagen */
background: transparent url(URL_imagenLogoHover) no-repeat left top;
}
El resultado será un header que cambiará de imagen si ponemos el cursor encima.

Ahora bien, un detalle a tener en cuenta es que si las imágenes son muy grandes, el efecto demorará porque la segunda imagen deberá ser cargada así que habrá que esperar que aparezca; eso pude ser importante ya que a veces, el efecto no será apreciable.

Para solucionarlo podemos recurrir a la vieja técnica de los sprites ¿Cómo es esto? En lugar de usar dos imágenes, usaremos sólo una. La mitad superior será la imagen "normal" y la mitad inferior será la imagen "hover". Así que esa imagen tendra un ancho igual al blog pero el doble de su altura (en este caso, 200 pixeles).


Cuando colocamos una imagen de fondo a un elemento no importa su tamaño. La imagen se ubicará donde le digamos. Si es muy chica, el resto del elemento se llena con el color indicado y, si la imagen es muy grande, se corta y alguna parte queda oculta. Esa característica es la que vamos a aprovechar.

¿Cómo posicionamos la imagen del fondo? Por defecto, se muestra empezando desde arriba a la izquierda y eso significan los últimos dos valores (left top). Es muy común leer que dicen 50% para centrarla pero, esos valores pueden ser cualquier otro así que podríamos decirle que en lugar de mostrar la imagen desde arriba, con lo cual la mitad queda oculta porque el espacio disponible es de sólo 100 pixeles de alto, la muestre desde a bajo y entonces, lo que se ocultará será la parte de arriba.

Cambiaríamos entonces las definiciones:
#header-inner {
background: transparent url(URL_imagenLogoDoble) no-repeat left top; /* es la imagen a usar */
height: 100px; /* debemos indicar la altura de esa imagen de fondo */
width: 100%; /* que ocupará todo el ancho del blog */
}

#header-inner:hover {
background-position: left bottom;
}
La imagen es una sola así que sólo se carga una vez y cuando realizamos el efecto, simplemente le decimos que se mueva para arriba (top) o para abajo (bottom).

El resultado puede verse en este blog de pruebas.

0

TinEye: Búsqueda de imágenes inteligente

TinEye es un buscador de imágenes con una característica que lo hace diferente, subimos una imagen desde nuestra PC o le indicamos la URL de una imagen ya alojada en la web y nos muestra los sitios donde se encuentra la misma u otra similar, las diferentes versiones existentes de la misma o aquellas que tengan la mejor resolución. Los formatos aceptados son JPEG, PNG y GIF hasta 1MB de tamaño.


Por ejemplo, un ejemplo sencillo con una imagen JPEG de 521x431 y 179.3KB muestra tres resultados: 384x306 de 16.6KB | 160x128 de 4.1KB | 120x150 de 4.4 KB

El servicio lo podemos usar de varias maneras y no es necesario registrarse aunque si lo hacemos, las imágenes que subimos se guardan y se crea un historial de búsquedas.


Podemos acceder directamente a la página, agregar una extensión para Firefox, instalar un plugin para Internet Explorer o añadir un bookmarklet a nuestros marcadores.

0

El buscador AJAX de Blogger

12 de julio del 2007 / 1 de junio del 2009 ... casi dos años. Una eternidad para cualquier producto web. Es el caso del gadget con el buscador Ajax de Blogger. Casi dos años accesible sólo via Blogger Draft lo que significa que no estaba terminado, que algo debía estar fallando o que había quedado traspapelado u olvidado debajo de una pila de seguidores. Recién ahora apareció el anuncio y ese gadget se ha agregado como elemento estándard (más información).

En realidad, lo curioso no era sólo que una empresa cuyo caballito de batalla es un buscador no tuviera un buscador integrado en sus blogs; lo curioso es que siempre funcionó bien (bien en téminos de Blogger) y, por lo que se ve, nada ha cambiado; el código sigue siendo el mismo. Lo vengo usando desde entonces y si bien es cierto que a veces tardaba un poco en conectarse, es un buscador que me gustó de entrada por dos motivos: porque muestra los resultados en la misma página y porque es fácilmente configurable con CSS lo que no es poco decir. Acostumbrados a tanto iframe y tanto script predigerido, es un soplo de aire fresco.

Lo agregamos desde Diseño | Elementos de la página | Agregar gadget, seleccionando Cuadro de búsqueda:


En la ventana, podemos marcar o desmarcar las distintas opciones que nos permiten definir dónde se harán las búsquedas. Cada una de ellas, aparecerá en una solapa diferente y todas ellas mostraran resultados preliminares en la misma página:


Este blog: es el buscador interno
Acceso desde aquí: busca en las entradas visibles, enlaces dentro de esas entradas, listas de sitios o listas de enlaces
Internet: es un buscador genérico
Listas de blogs y enlaces: agrega la posibilidad de buscar en todos los sitios agregados al blogroll

Una vez que definimos esto, lo agregamos y lo ubicamos donde queremos que se muestre.


Por defecto, leerá los datos de nuestra plantilla y se adaptará a las características gráficas de nuestro sitio. Veremos el cuadro de búsqueda y nada más. De manera automática, se añadirá un DIV oculto sobre el área de posts que es donde se mostrarán los resultados:
<div id="uds-searchControl">
.......
</div>
Eso quiere decir que tendremos dos áreas que podremos personalizar, el cuadro de búsquedas y el cuadro de resultados.


Si vamos a la plantilla y expandimos los artilugios veremos el código comenzando con algo así:
<b:widget id='CustomSearch1' locked='false' title='' type='CustomSearch'>
<b:includable id='main'>
<!-- el título igual que cualquier otro widget -->
.......
<!-- el código en si mismo -->
<div class='widget-content' style='width:95%'>
<div expr:id='data:widget.instanceId + &quot;_form&quot;'>
<span class='cse-status'><data:loadingMsg/></span>
</div>
</div>

<!-- y aquí comienza lo interesante -->
<!-- override gsearch.css -->
<style type='text/css'>
#uds-searchControl .gs-result .gs-title, #uds-searchControl .gs-result .gs-title *, #uds-searchControl .gsc-results .gsc-trailing-more-results,
#uds-searchControl .gsc-results .gsc-trailing-more-results * {color:<data:linkColor/>;}
#uds-searchControl .gs-result .gs-title a:visited, #uds-searchControl .gs-result .gs-title a:visited * {color:<data:visitedLinkColor/>;}
#uds-searchControl .gs-relativePublishedDate, #uds-searchControl .gs-publishedDate {color: <data:dateColor/>;}
#uds-searchControl .gs-result a.gs-visibleUrl, #uds-searchControl .gs-result .gs-visibleUrl {color: <data:urlColor/>;}
#uds-searchControl .gsc-results {border-color: <data:borderColor/>; background-color: <data:backgroundColor/>;}
#uds-searchControl .gsc-tabhActive {border-color: <data:borderColor/>; border-top-color: <data:activeBorderColor/>; background-color: <data:backgroundColor/>; color: <data:textColor/>;}
#uds-searchControl .gsc-tabhInactive {border-color: <data:borderColor/>; background-color: transparent; color: <data:linkColor/>;}
#uds-searchClearResults {border-color: <data:borderColor/>;}
#uds-searchClearResults:hover {border-color: <data:activeBorderColor/>;}
#uds-searchControl .gsc-cursor-page {color: <data:linkColor/>;}
#uds-searchControl .gsc-cursor-current-page {color: <data:textColor/>;}
</style>

<!-- el ícono para editar el elemento -->
<b:include name='quickedit'/>
</b:includable>
</b:widget>
En esa parte de STYLE, Blogger dice "override gsearch.css" y eso es lo importante y lo que lo hace distinto a tantos otros gadgets. Las características gráficas son genéricas y se cargan desde una hoja de estilo externa (gsearch.css). Para que se adapte a nuestro sitio, Blogger sobrescribe algunas propiedades y por eso lo hace allí, justo después de cargar el gadget.

Por defecto, sólo cambia algunos datos para igualar los colores de nuestra plantilla pero, nada impide agregar o modificar más definiciones.


Empecemos con el cuadro del buscador que es el más sencillo. Hay cuatro definiciones importantes:
input.gsc-input {
/* es el cuadro donde se ingresa el texto a buscar */
}
input.gsc-search-button {
/* es el botón "Buscar" */
}
.gsc-branding-text {
/* es el texto inferior "con la tecnología de" */
}
.gsc-branding-img-noclear {
/* es la imagen con el logo de Google*/
}
Configurar el cuadro de resultados requiere paciencia, tiene muchas definiciones y es bastante confuso pero veamos si es posible encontrar cada parte o por lo menos, aquellas más importantes.

El bloque total, el rectángulo oculto donde se muestran los resultados del buscador se llama uds-searchControl así que podemos usarlo si es necesario modificar su ancho y sus márgenes:
#uds-searchControl { }
En la parte superior se muestran las solapas con las opciones que hayamos seleccionado y ese rectángulo podemos modificarlo mediante:
#uds-searchControl .gsc-tabsArea { }
Difícilmente sea necesario hacerlo, más importante son las solapas. Hay de dos tipos y en ambas podríamos establecer bordes, color y fuente de los textos, colores de fondo, etc:
#uds-searchControl .gsc-tabhInactive { /* son las solapas inactivas */ }
#uds-searchControl .gsc-tabhActive { /* es la solapa activa */ }
A la derecha de estas se muestra un botón que permite volver a ocultar los resultados y tiene dos definiciones:
#uds-searchClearResults { }
div.gsc-clear-button { }

Todo lo demás se encuentra dentro de un rectángulo que tiene un borde visible y un padding que separa el contenido de esos bordes:
#uds-searchControl .gsc-results { }
Los resultados en si mismos tienen cuatro definiciones a las que podemos agregarles fondos, cambiar colres y fuentes, etc:
#uds-searchControl .gs-result .gs-title, 
#uds-searchControl .gs-result .gs-title *,
#uds-searchControl .gs-result .gs-title a:visited,
#uds-searchControl .gs-result .gs-title a:visited * { /* es el título de cada una */}

#uds-searchControl .gs-relativePublishedDate, #uds-searchControl .gs-publishedDate { /* es la fecha */}

#uds-searchControl .gs-result a.gs-visibleUrl, #uds-searchControl .gs-result .gs-visibleUrl { /* es enlace inferior */}

#uds-searchControl .gs-result .gs-snippet { /* es el resumen de las entradas encontradas */}
En esta última, se resalatan las palabras buscadas, eso se hace con una etiqueta B así que podríamos agregar algo así si quisiéramos que resaltarán de otro modo:
#uds-searchControl .gs-result .gs-snippet b { }

En la parte inferior, lo que veremos es un área de paginación llamada:
.gsc-results .gsc-cursor-box { }
En ese área, las páginas se muestran como enlaces numerados definidos por:
#uds-searchControl .gsc-results .gsc-cursor-box .gsc-cursor-page { }
y la página actual está resaltada:
#uds-searchControl .gsc-results .gsc-cursor-box .gsc-cursor-current-page { }
a la derecha, el enlace "más resultados" nos abrirá el buscador de normal:
#uds-searchControl .gsc-results .gsc-cursor-box .gsc-trailing-more-results { }

0

"En construcción"

Hace tiempo publiqué una entrada sobre como redireccionar el blog a otro donde mostrar una página de "en construcción".

Este sistema no es del todo adecuado y, aunque en Blogger es bastante difícil conseguir según que cosas, siempre hay alguien que encuentra una mejor solución.

En Quite Ramdom hay publicado un sistema para ocultar el blog mientras estamos en construcción que me parece la más acertada hasta el momento.

Esto nos evitará el tener que "privatizar" el blog mientras trabajamos en algún cambio importante, ya que para el administrador el blog estará disponible como siempre, mientras que para las visitas permanecerá oculto (se cargará como siempre, pero solo podrá verlo el administrador).

Para no desconcertar a los usuarios, una vez han accedido al blog podrían ver en lugar de este una imagen que nosotros hayamos colocado con un logo o un texto de "En construcción" por ejemplo.


En construcción


[1] En nuestro panel nos situamos en Edición HTML y localizamos la etiqueta <body> en el código de nuestra plantilla.

Justo después de esta etiqueta, añadimos esta línea de código:
<span class="item-control blog-admin">

[2] Bajamos ahora por el código de la plantilla, y casi al final del mismo, vemos la etiqueta de cierre </body>

Justo antes de esa etiqueta, colocamos el cierre del código anterior:
</span>


Una vez guardamos esos cambios, el blog estará oculto a los usuarios, para evitar que estos vean una página en blanco cuando accedan al blog, colocamos una imagen o logo de "En construcción" que se vea centrada en la pantalla.

Lo hacemos justo después de <body>, es decir, antes de la primera línea de código que habíamos colocado al comienzo del "truco":
<div style="text-align: center;"><img src="URL_de_la_imagen"/></div>


Visto en: Quite Random

0

Twitter y los sentimientos

Twitter Mood Reader se encarga de leer los sentimientos de nuestros tweets, dicho de otra forma un poco más convincente refleja con una expresión aquello que decimos en Twitter.
Según Juanguis de Punto Geek son ese tipo de cosas que no tienen casi utilidad (pero le encantan) yo creo que ese gusto es compartido por muchos.
Veamos quien se resiste.