Alters

Diseño web: máxima compatibilidad: Tips & tricks


Buenas!

Llegamos a la última entrega de diseño web, la que seguramente sea la más extensa, y la que llevará más carga práctica.

Ya que será una entrega larga y con varios puntos, vuelvo a dejar el índice:

  1. Porcentajes
  2. Agrupar contenido en clases superiores
  3. Inherit, initial u omitir
  4. Contenido "centrado"
  5. Contenido que se "redimensiona"
    1. Fondo
    2. Contenido
  6. Jugar con la transparencia
  7. Efectos "misc"
    1. Scroll modificado
    2. Cajas con borde
    3. Modificar "select"
    4. Scroll "dependiente"
    5. Editar listas
  8. Div vs Span
  9. Compatibilizar con otros navegadores


  • Porcentajes
Los porcentajes pueden usarse en los atributos:
  • Top
  • Left
  • Width
  • Height
Sirven para indicar medidas porcentuales, es decir, no son medidas fijas (como lo sería "width: 25px;")
Al ser un porcentaje, cogerán el valor de su parent node (padre) como 100%.

Un ejemplo: supongamos la siguiente estructura:


<div class="clase1">
  <div class="sclase1">
    <div class="sclase2">
    </div>
    <div class="sclase3">
    </div>
  </div>
</div>

style:

.clase1{width:200px;height:200px;top:0px;left:0px;position:relative;}
.sclase1{width:50%;height:50%;top:20%;left:10%;position:relative;}
.sclase2{width:10%;height:100%;top:0;left:0;position:relative;}
.sclase3{width:40%;top:20px;position:relative;}

Bien, analicemos cómo quedaría:

Esta es la representación del navegador del ejemplo. A destacar dos aspectos: he añadido un "background-color" a cada clase; y he añadido "height:1px" a ".sclase3", para que se vea (ya que si no tiene los atributos "width" o "height", se adapta al contenido; y a contenido vacío, el div "desaparece").

Ahora veamos las medidas "reales" de cada div:









  • Clase1:
    • Width: 200px
    • Height: 200px
    • Top: 0px;
    • Left: 0px;
  • Sclase1:
    • Width: 100px (50% de parent - 200px -)
    • Height: 100px (50% de parent - 200px -)
    • Top: 40px (20% del largo - height - de parent - 200px -)
    • Left: 20px (10% del ancho - width - de parent - 200px -)
  • Sclase2:
    • Width: 10px (10% de parent - 100px -)
    • Height: 100px (100% de parent - 100px -)
    • Top: 0
    • Left: 0
  • Sclase3:
    • Width: 40px (40% de parent - 100px -)
    • Height: variable (1px en el ejemplo)
    • Top: 20px (20% de parent - 100px -), pero son en total 120 px partiendo desde la esquina superior izquierda de "Sclase1" (verde), ya que "Sclase2" ocupa todo el largo.
    • Left: 0

  • Agrupar contenido en clases superiores:
Esto es algo que tendremos que hacer a posteriori de que el CSS esté listo.

Esta medida da como resultado un CSS más pequeño y manejable, y se basa en el siguiente concepto:

"Si todos los hijos (child node) tienen una misma característica, ésta la puede implementar el padre (parent node) y que así, la hereden los hijos".

Es decir, si yo tengo algo así:


.clase1{top:0px;left:0px;}
.sclase1{font-family: arial;font-weight:700;}
.sclase2{background-color:blue;}
.sclase3{font-family:arial;}
.sclase4{font-family:arial;font-weight:700;}

<div class="clase1">
  <div class="sclase1">
     HOLA, SCLASE1
  </div>
  <div class="sclase2">
    <div class="sclase3">
       HOLA, SCLASE3
    </div>
    <div class="sclase4">
       HOLA, SCLASE4
    </div>
  </div>
</div>

El resultado sería el siguiente:

  • HOLA, SCLASE1: Texto en negrita, fuente arial
  • HOLA, SCLASE3: Texto normal, fondo azul, fuente arial
  • HOLA, SCLASE4: Texto en negrita, fondo azul, fuente arial.
Como vemos, todo el texto es en arial, por lo que podríamos añadir "font-family: arial" a "clase1" y eliminarlo de las demás. De este modo, todos los hijos (a no ser que se definiera una regla específica) heredarían la fuente de "clase1".

Con esto, ahorramos algo de espacio en el CSS, lo que lo hará más pequeño, y por tanto, más fácil de descargar para el navegador.

  • Inherit, Initial, Omitir
Inherit es un valor de atributo que equivale a "heredar" de un parent. En chrome, y versiones recientes de IE, dejar un atributo vacío equivale a hacer "inherit", si el parent tiene dicho atributo definido.

Initial es un valor de atributo que equivale a dejar el atributo a "por defecto" del navegador. Si, por decir algo, la fuente por defecto de nuestro navegador es "calibri", y dentro de un div con "font-family:arial" ponemos un div con "font-family:initial", el texto de éste será "calibri". El valor initial no es soportado por todos los navegadores (me refiero a algunas versiones de IE...)

Omitir el atributo en cuestión es dejar que el explorador decida: por lo general se sigue la siguiente norma: si el parent tiene el atributo, el child lo hereda; en caso contrario, se hace "initial". Aquí está la trampa, ya que cada navegador puede tener sus reglas de "omitir" y de "initial"...

Yo personalmente siempre intento definir el máximo de atributos (es decir, intentar dejar el mínimo de omitidos, omitiendo solamente los que quiero heredar), y evito usar "initial", ya que algunos exploradores no lo aceptan. Inherit también da problemas con IE, así que muchas veces no lo uso (por eso uso el omitir).

  • Contenido centrado
Siempre queremos centrar el contenido de nuestras webs... ahora os daré un par de "trucos" para que siempre quede todo bien centrado:

  • Contenido centrado: para ello, lo metemos todo en un div, y le añadimos las siguientes reglas de estilo:
    • margin-left: auto
    • margin-right: auto
    • margin-top: auto
  • Texto centrado verticalmente: para conseguirlo, modificaremos el interlineado, del siguiente modo:
    • line-height: **height del div**

  • Redimensionar contenido

Para hacer un fondo que se redimensiona, basta con hacer un par de cambios:

Creamos un div, fuera de cualquier otro, y dentro insertamos el fondo (como <img>). A la imagen le ponemos el siguiente estilo:

z-index:1;position:absolute;width:100%;height:100%

Y voliá!

Para que el contenido se redimensione, tenemos que jugar de nuevo con los porcentajes en nuestro div principal. El "inconveniente" es que al redimensionar el contenido, todo tendrá que cambiar de tamaño, y, por tanto, tendremos que ir siempre con porcentajes.

  • Jugar con la transparencia
La transparencia de un objeto es algo que se puede usar para crear efectos que hagan destacar unos elementos sobre otros. Por ejemplo, algo que está fuera de un rango, puede tener cierta transparencia para indicar que precisamente está fuera del rango.

El sistema recomendado para la transparencia es el siguiente:

filter:alpha(opacity=X);-moz-opacity: .X;opacity: .X

Donde X variará entre 0 (transparente) y 100 (opaco). Daros cuenta de que los dos últimos atributos van precedidos de "." (es decir, son del estilo 0.X, pero se puede omitir el "0").

El primer atributo es para que la transparencia se vea en IE; el segundo para mozilla; el último es de propósito general.

Hay que tener cuidado con la opacidad, ya que siempre se hereda (aunque se modifique el atributo en una child class). Por ello, siempre que queráis hacer un div con transparencia, y "dentro" (visualmente hablando) un div sin transparencia, lo que recomiendo es hacer los dos div "hermanos" (al mismo nivel), y ajustar las alturas para que de la sensación de que uno está dentro del otro.


  • Efectos "misc"
    • Scroll modificado
Se puede modificar el scroll a varios niveles: desde hacer que desaparezca forzosamente, hasta cambiar su aspecto.

Para el primer propósito, haremos uso de los atributos "overflow", y sus variantes "overflow-x" y "overflow-y". Los valores que pueden adoptar, son: hidden, visible, auto (initial, inherit).

Hidden esconde siempre el scroll; visible lo muestra siempre; auto deja que el explorador decida.

Para modificar el scroll, podemos recurrir a métodos propios de los navegadores, tales como -webkit-XXX, o modificar el body para IE. Otra manera es recurrir a jquery (supongo...).

    • Cajas con borde:
Podemos jugar con el borde de un div, para que enmarque información u otras funciones. Al atributo "border" se le pueden añadir sufijos, como "-bottom", "-top"... para especificar solo una parte del div. Con ello podemos conseguir líneas rectas.

    • Modificar Select:
El select es un input que no se puede cambiar mucho, pero podemos adaptarlo un poco para darle un estilo propio (sin necesidad de jquery).

Para ello, vamos a ver unos ejemplos:

Ejemplo 1: metemos el select dentro de un div, le cambiamos el fondo, le quitamos el borde y lo hacemos más pequeño:


Ejemplo 2: partiendo del ejemplo 1, hacemos el select más ancho que el div, de manera que la flecha desaparezca. A su vez, le ponemos un fondo al div, el cual sea una imagen de una flecha, y la colocamos al borde, simulando que es el botón. Al hacer click sobre la imagen (o cualquier otro punto) se desplegará el select.


    • Scroll dependiente
Para ello, usaremos un poco de JavaScript. Añadiendo el manejador "onresize" podemos controlar cuándo la página se redimensiona.

Dentro del manejador, podemos controlar el tamaño de la pantalla o de cierto div, y modificar el CSS para que el scroll pase, por ejemplo, de hidden a visible.


    • Editar listas
Para editar una lista desordenada (ul) no tenemos más que cambiar el estilo, de la siguiente manera:

.clase li {background: #FFFFFF url("imagen") 0 10px no-repeat;padding: 0 0 5px 22px;}

Analicemos: el background lo establecemos así: fondo blanco; con la imagen especificada en "url"; con una posición de 0,10 (la modificaremos sobre la marcha para que quede en la posición que queramos);la imagen no se repetirá, y tendrá una distancia al parent de 0,0,5,22 (esto también lo modificamos sobre la marcha).

Entonces, en nuestra "ul", le añadimos esta clase y ya lo tenemos.

  • Div vs Span
Como elementos contenedores, tenemos básicamente "div" y "span".

El primero es un bloque, mientras que el segundo es como una capa. Es decir, si un span tiene especificados un ancho y un alto, es muy probable que no los adopte; mientras que el div si (ya que es un bloque).

Yo personalmente no uso mucho los span; los uso especialmente para definir estilos de texto concretos (ya que el span no es un bloque). Para el resto, uso div.

  • Compatibilizar con otros navegadores

Esta es la parte más difícil de todas... cada navegador tiene sus propias reglas... por lo que a veces pensamos: "¿un CSS para cada navegador?"; podemos hacer eso, usando una función JS que determine qué navegador y versión está siendo usada... pero hay otras opciones, los llamados "hacks".

Ahora os explicaré una serie de reglas para crear reglas específicas para navegadores en concreto:

  • Para IE:
    • 8 y anterior: antes del ";" si añadimos "\9", dejaremos esa regla solo para estas versiones de IE. 
    • 7 y anterior: si ponemos un "*" antes de la regla, dejaremos esa regla solo para estas versiones.
    • 6 y anterior: si ponemos un "_" antes de la regla, dejaremos esa regla solo para estas versiones.
  • Para FF:
    • @-moz-document url-prefix(){}
      • Dentro de las llaves reescribiremos todas las clases que queramos cambiar solo para FF
  • Para Opera:
    • @media not screen and(1){}
      • Dentro de las llaves reescribiremos todas las clases que queramos cambiar solo para Opera
Es decir, si tenemos las siguientes clases:

.clase1{top:10px;_top:20px;*top:30px;top:40px\9;}
@-moz-document url-prefix(){.clase1{top:60px;}}
@media not screen and(1){.clase1{top:70px;}}

Para cada navegador se verían diferentes top, a saber:
  • Default: 10px
  • IE 8: 40px:
  • IE 7: 30px;
  • IE 6: 20px;
  • FF: 60px;
  • Opera: 70px;
Aplicando estas reglas, podemos hacer que el estilo esté todo en un archivo, y a la vez que sea específico para cada explorador.

Finalmente decir que quedan por explotar muchos aspectos de CSS, como hacer div girados X grados, los fondos con degradado, sombras... todo ello quizás lo expongo en una nueva sección de CSS, quién sabe (queda anotado en mi tablón!).

También comentar, a todo gurú del CSS que lea esto, que se que es posible que hayan cosas inexactas... sed indulgentes con mis conocimientos de CSS!

Supongo que esta será la última entrada del año en el blog... así que hagamos planes para el año que viene!


  • BuscaM!nas: lo siento, pero me veo obligado a dejar el proyecto de lado durante mucho mucho tiempo, ya que tengo un montón de proyectos por en medio que quiero acabar antes de ponerme de nuevo con esto.
  • Blog: Para el año que viene, intentaré ser más novedoso, e introducir paranoicos programas que hagan que os preguntéis qué me tomo para programar esas cosas... jeje... dejo una lista de temas que tengo pendientes de meter en el blog:
    • CSS avanzado
    • Optimización PHP
    • Uso de htaccess
    • HPL2
    • M!nas
      • MSAccess
      • COBOL
      • PHP
    • Varios (relleno) -> solo por si acaso...
    • PPHP -> paranoia en la que en breve me pondré a trabajar
    • COBOL avanzado
    • ASM
    • "Hacking"
      • cURL
      • VB.net
        • Procesos
        • FTP
        • HTTP
    • D - COBOL -> trabajando en ello
    • NS - NA -> trabajando en ello
    • Control remoto -> trabajando en ello
    • PS2Cloud -> trabajando en ello
    • Criptografía -> ampliando conocimientos cada día...
  • Personal: Como propósitos para el próximo año tengo (en cuanto a informática):
    • Adelantar mi libro (ya tengo uno terminado y registrado... ya os comentaré si me lo publican)
    • Quizás empezar uno nuevo
    • Adelantar mis proyectos (al menos PS2Cloud  y el control remoto tienen que estar para este año)
    • Adelantar la definición de mi "lenguaje de programación" (sí, estoy tan mal de la azotea que estoy creando un lenguaje de programación - bueno, estoy a un nivel teórico aún)
    • Hacer al menos 5 series de entradas en el blog
    • Terminar ISPA
    • Aprender algo de IA
    • Aprender sobre algún tema de Hardware
    • Aprender sobre algún tema de Software
    • Aprender sobre algún tema "misc" (vulnerabilidades, exploits, "bajo nivel" del S.O...)
Como veis, siempre trato de aprender cosas nuevas, y es que me gusta aprender cosas nuevas...

En fin, supongo que hasta el año que viene no volveré a escribir... así que

¡Hasta la próxima!

Diseño web: máxima compatibilidad: Maquetar el esqueleto con CSS

Buenas!

En esta entrada, veremos cómo maquetar el esqueleto de nuestra web, usando CSS.

Así, esta será la última entrada que trate de, por así decirlo, la "teoría" de CSS. La siguiente entrada serán trucos y "hacks" para obtener buenos resultados a varios niveles: ya sean archivos CSS más reducidos, o efectos misceláneos que den más vida a nuestras obras.

Empecemos con un poco de teoría:

Para crear un esqueleto con CSS, hay que tener en cuenta que debemos meter objetos dentro de otros objetos. Esto nos ayudará a mover grupos de ellos sin tener que cambiar casi nada.

Y, ¿cómo agrupamos estos objetos? yo siempre intento seguir el siguiente esquema:

  • Creo un objeto (div) principal, que engloba todo
  • Sobre el diseño, trazo líneas rectas, allí donde se pueda.
    • Éstos serán los objetos (div) principales.
  • Mientras se pueda, iré sobre esos objetos, haciendo partes más pequeñas.
Para ilustrar el ejemplo, usaré la imagen de aquel boceto que subí hace unas cuantas entradas.


He hecho cuadrados de diferentes colores para -intentar- ilustrar cómo se haría un esqueleto de este modelo (o, al menos, como lo haría yo).
  • En color rojo: div general, lo engloba todo
  • En color rojo oscuro: los dos div principales; la sección de botones y la sección de contenido.
  • En color verde: ítems dentro de los anteriores, a saber:
    • Parte de botones: cada uno de los botones
    • Parte de contenido: la sección "puramente" de contenido y la sección de cabecera
  • En color azul: ítems dentro de los anteriores, que son:
    • Parte de contenido:
      • Parte de cabecera: contenedor "imaginario" que engloba todo el contenido de la cabecera
  • En color lila-morado-violeta: ítems dentro del ítem azul:
    • Parte de contenido:
      • Parte de cabecera:
        • Parte de contenido de cabecera:
          • Sección para logo
          • Título de página
También he dejado las guías del dibujo, para mostrar que no siempre los div que salen son los que muestran las guías (en este caso, el div de color azul).

Ahora que ya sabemos cómo estarán distribuidos los div dentro del esqueleto, falta maquetar unas clases CSS que hagan la distribución.

Entonces, creamos uno grande de 800x600, y dentro de este irán dos: para los botones y para el contenido.

En cuanto a los botones, una vez creado el div que aguantará todos los botones, no tenemos más que crear cuatro div consecutivos, ya que éstos ocuparán el 100% del ancho, y por tanto, se mostrarán automáticamente uno debajo de otro.

Para el contenido, haremos un div centrado para el contenido en sí, y otro para la parte de la cabecera.

En la parte de la cabecera, haremos un div centrado para el contenido. Dentro de ese div, haremos uno pequeño para el logo y otro para el título.

En cuanto queramos modificar algún componente, no tendremos más que cambiar alguna cosa del CSS... pero, por ejemplo, digamos que queremos ensanchar todos los botones; no tenemos más que ensanchar el div que contiene todos los botones...

Por ahora, esto es todo para esta entrada; se que no es gran cosa, pero quiero reservar gran parte del material para la próxima entrada, donde veremos varios aspectos del CSS que nos ayudarán a dar vida a las web y a que sean compatibles con todos los navegadores.

Saludos, buenas fiestas y...

¡Hasta la próxima!

Diseño web: máxima compatibilidad: Clases con CSS


Buenas!

Hacía tiempo que no escribía... voy muy muy liado, no paro...

En esta entrada toca hablar própiamente de las clases CSS. Como ya dije, yo no soy unos de esos expertos gurús capaces de armar un "DaVinci-Web" (a los que admiro por sus elevados conocimientos); yo uso el CSS para cosas básicas: ancho, alto, color de fondo... el resto de efectos los trabajo de otras maneras (si hago efectos extraños, claro).

Pues bien, para maquetar cosas con CSS son necesarias las clases.

Éste es el esquema de una clase:

.clase{
  atributo1: valor;
  atributo2: valor;
}

Pero vamos a ver que, normalmente, ahorraremos espacio al máximo, y haremos las clases en una sola línea, las juntaremos, le haremos especificaciones, etc.

¿Que vamos a qué?

Explico, paso a paso, jeje.

Una clase "simple" es como he puesto arriba, pero puede tener muchas más especificaciones, como por ejemplo, hacer un estilo específico del estilo específico...  esto se consigue dejando un espacio después del nombre de la clase y escribiendo a continuación el nombre de una etiqueta html; por ejemplo:


.clase td{
  atributo1: valor;
  atributo2: valor;
}


Vamos un poco más allá: podemos generalizar este estilo para más de una etiqueta, separándolas por comas, como por ejemplo:


.clase td, a{
  atributo1: valor;
  atributo2: valor;
}


Otra cosa que se pueden hacer con las clases es definir más de una clase a la vez, de nuevo, usando comas:


.clase td, a, .clase2, td{
  atributo1: valor;
  atributo2: valor;
}

Sigamos viendo cosas: vamos con los estados de los objetos.

Algunas etiquetas tienen estados fundamentales, como:

  • hover: cuando el ratón está encima
  • active: cuando le hacemos click
  • visited: cuando (un enlace) ya ha sido visitado
  • link: color de un enlace
Todos estos estados tienen, para sus etiquetas, valores predefinidos. Pero los podemos modificar añadiendo dos puntos ":" seguido del valor. Por ejemplo:


.clase td:hover, a:hover{
  atributo1: valor;
}
  
La siguiente modificación que puede sufrir una clase es que se aplique a una etiqueta en sí, es decir:


a:visited{
 atributo1: valor;
 atributo2: valor;
}

esta regla se aplicará a todos los enlaces (<a>) del documento. Fijaros que no va precedida por el punto "."

Finalmente, quedan por ver los estilos propios  Éstos son objetos especiales propios de cada navegador. Personalmente intento evitarlos, ya que en algunos navegadores (IE, por ejemplo) no hay un estilo propio equivalente, y la web deja de ser compatible...

Un estilo propio se caracteriza porque suele ir precedido por un guión "-", de manera que podemos encontrar:

-webkit-
-o-
-f-

para navegadores webkit (chrome, por ejemplo), opera, y firefox.

Ahora bien, para ahorrar espacio, se suelen apilar las clases en una sola línea, es decir:


.clase1 a, td, .clase2{atributo1:valor;atributo2:valor;}

Con esto ya sabremos defendernos con las clases. Ahora falta rellenarlas.

Para ello hace falta nada más que un poco de inglés. Algunos atributos que siempre (o casi siempre) se usan son:
  • top
  • left
  • width
  • height
  • position
  • background-color
  • background-image
  • font-family
  • font-size
  • color
  • padding
Vamos por partes para explicarlos:

 - Top y left: indican la posición X e Y del elemento, tomando como punto (0, 0) la esquina superior izquierda de su elemento padre. Ambos pueden ser negativos, y deben especificar medida (px, generalmente).

 - Width y height: especifican el ancho y el alto del elemento. No tiene sentido que sean negativos. Tienen que tener medida (px, generalmente). En caso de no estar especificados, el explorador los hará tan grandes como necesite (lo que puede ser una ventaja y un inconveniente)

- Position: este es un tema escabroso. La verdad es que nunca he sabido qué hace del todo exactamente, pero hay una cosa clara: si position es absolute, el objeto se queda en una posición que nosotros le digamos en top y left, mientras que si es relative será relativo a los demás objetos.

 - Background-color: especifica el color de fondo: puede usarse un RGB (#nnnnnn) o  un color prefefinido (por ejemplo "blue", "darkRed", "cyan").

 - Background-image: especifica una imagen de fondo. Se suele combinar con background-size y background-repeat (para tamaño y para especificar si se repite o no)

 - Font-family: decimos qué tipo de fuente queremos usar.

 - Font-size: tamaño de la fuente, en px generalmente

 - Color: color del texto, en RGB o nombre común

 - Padding: distancia (como un borde) al borde del contenedor. Generalmente en px.

Ahora que ya sabemos los principales atributos, os voy a poner un ejemplo: el contenedor que uso yo para remarcar las cosas, en forma de clase (yo lo uso como style)


.caja{
  padding: 10px 10px;
 font-family: arial;
 font-size: 14px;
 background-color: #EFEFEF;
 border: 2px solid #999;
}

o


.caja{padding:10px 10px;font-family:arial;font-size:14px;background-color:#EFEFEF;border:2px solid #999;}

Como veis no pongo ni alto, ni largo ni posiciones... para que se coloque solo y ocupe lo que necesite.

Con esto ya sabemos un poco más de estilos. La próxima entrada veremos un ejemplo práctico de cómo implementar un esqueleto CSS, usando el ejemplo que ya empecé en su día.

Saludos y ¡Hasta la próxima!

Diesño web: máxima compatibilidad - Interpretar estilos como el navegador

Buenas!

Esta entrada será algo corta, ya que hay poco que explicar sobre este aspecto...

Veamos; hay tres posibles maneras de especificar estilos en HTML:

  • File
  • Inline
  • Direct
Los tres tipos son bastante explícitos: por fichero, en linea y directo. Pero, ¿Qué significa cada uno?

Ahora lo explicamos de manera sencilla:

File:

El estilo "tipo file" se basa en crear un archivo aparte del HTML (como el que segrega frontend y backend en una aplicación), incluyéndolo después en nuestro archivo HTML.
  • Ventajas
    • Usabilidad
    • Portabilidad
    • Fácil de mantener
  • Inconvenientes
    • Para que sea usable y portable, tiene que ser muy general
Para usar un archivo de estilo, tenemos que crear un archivo con extensión ".css", con un bloc de notas o cualquier herramienta de desarrollo que uséis.

Una vez creado el archivo, lo rellenamos con nuestro estilo (ya veremos cómo), y en el HTML incluimos la siguiente línea:

<link rel="stylesheet" type="text/css" href="nuestra ruta" />

En donde pone "nuestra ruta" pondremos la ruta a nuestro archivo. OJO, debe ser ruta de internet (tipo http://www...) si es absoluta; en caso contrario da lo mismo.

Inline:

El estilo "tipo inline" es similar al "file", pero haciéndolo todo junto. Es decir, separamos HTML de estilos, pero en el mismo archivo.

  • Ventajas
    • Usabilidad (menor que file)
    • Portabilidad (menor que file, ya que habría que hacer copia-pega)
    • Fácil de mantener
  • Inconvenientes
    • Para estilos similares, tenemos que replicar código
Para hacer un estilo "inline", en nuestro HTML declaramos un estilo, tal que:

<style>
<!--nuestro estilo-->
</style>

Dentro de las etiquetas style iría nuestro estilo, como iría en el archivo a parte.

Direct:

Esta modalidad permite definir el estilo de cada elemento en el momento de definirlo. Se basa en una mezcla de HTML y estilos.

  • Ventajas:
    • Estilo personal
  • Inconvenientes:
    • Nada portable
    • Complicado de mantener
Para hacer un estilo "direct", tenemos que hacer algo así:

<input style="estilo" />

Dentro de "style" irían las reglas de estilo de ese (y solo ese) elemento.

Ahora que ya sabemos cómo son los tipos de estilo, veremos cómo los interpreta el navegador:

El orden de prioridad que usa el navegador es el siguiente:
  • File
  • Inline
  • Direct
Es decir, primero carga el archivo (si lo hay). Después evalúa si hay etiquetas "style", y en caso de ser así, sobreescribe las reglas que hubieran en el fichero.

Finalmente, mientras carga los objetos, revisa si tienen el atributo "style". En caso de ser así, se modificará, solo para ese elemento, las reglas establecidas.

Para que se ve claro, haré un ejemplo:

Supongamos que tengo una regla llamada "color", tal que:

color{
 sin bordes
 alto 100px
 ancho 100px
 fondo rojo
}

y en una de las páginas de mi web, quiero que los fondos sean azules, podría hacer:

<style>
color{
  fondo azul
}
</style>

Pero, imaginad que hay un párrafo que ha de tener 200px de ancho, pues haría:

<p class="color" style="ancho 200px">

La parte en negrita es un atributo de los elementos HTML que permite anclar una regla a un elemento.

Así, la estrategia a seguir es la siguiente:

  • Creamos reglas generales en un estilo "tipo file"
  • Creamos reglas más específicas en un estilo "tipo inline"
  • Ajustamos al detalle los estilos con algo "tipo direct"
Ahora que ya sabemos cómo empezar a hacer estilos, y tenemos nuestra maqueta, podemos empezar a definir nuestras reglas.

Pues, 

¡Hasta la próxima!

Diesño web: máxima compatibilidad - Diseñando el esqueleto a papel

Buenas!

Seguimos con el tema del diseño web...

Ahora que ya sabemos cómo hacer la web algo más estándar, es la hora de empezar con el diseño en sí.

Pero, para poder diseñar bien algo, primero es necesario hacer bocetos, para ver cómo quedaría todo.

Así, se coge un papel en blanco y se empiezan a plasmar ideas, y cuando tenemos una buena la desarrollamos. Recomiendo usar escala para ver mejor los resultados finales.

Cuando tengamos un diseño que nos agrada, podemos (si queremos) pasarlo a PC. Yo lo hago con Corel y mucha paciencia...

Os dejo el último diseño que hice (img):

img1
El tamaño original es 800x600, y lo hice a escala 3:100 (es decir, en el papel era un cuadro de 24x18, y 3 cm equivalen a 100px).

Como veis es un diseño sencillo: se distinguen tres partes principales (lateral - 5 secciones, central - cuadro grande, superior - barra con 2 secciones).

Al tener la escala, fue fácil llevarlo a tamaño real, y fue también fácil llevarlo a web con CSS.

Obviamente, este diseño va un poco en la línea del producto que promociona; es decir, cada tipo de página puede tener un diseño "más acorde" a ello, de manera que no pondría, por ejemplo, colores apagados (grises, negros) en un diseño de una juguetería infantil.

No solo los colores influyen, sino las formas. Formas redondeadas pueden dar un poco de dinamismo en un diseño, pero también son más difíciles de llevar a cabo.

Veamos un poco en profundidad qué cosas se pueden tener en cuenta a la hora de diseñar:
  • Público al que va dirigido
  • Tipo de producto (por ejemplo, las redes sociales tiran hacia el azul)
  • Contraste fondo/contenido
  • Efectos adicionales (sombras, bordes redondeados...)
  • Tamaño óptimo (para webs pequeñas, pienso que 800x600 es un buen tamaño)
  • Accesibilidad
Hasta aquí, tenemos ya todo preparado para llevar nuestra web de la cabeza a internet.

En la próxima entrada (será bastante corta...), veremos cómo analiza, a grosso modo, el estilo nuestro navegador.

Así que,

¡Hasta la próxima!

Diseño web: compatibilidad máxima - W3C

Buenas de nuevo!

Empezamos con el tema de diseño web, temporalmente.

En esta entrada hablaremos de W3C.

W3C significa "World Wide Web Consultorium", es decir, un consultorio de la WWW. Como tal, tiene herramientas específicas para validar nuestro HTML, CSS... e incluso tiene manuales de referncia de los mismos (incluyendo JS).

Pero, ¿Qué es "validar" un HTML?

Veréis, muchas veces codificamos de manera "no estándar" nuestras web. Esto no significa que estén mal, sino que no es un documento estándar, acorde con las directrices de W3C.

Hoy en día no pasa nada, ya que la mayoría de los navegadores incluyen funciones que "estandarizan" nuestro HTML; pero antaño, no seguir un estándar daba webs muy diferentes dependiendo del navegador.

Bien, ahora no penséis que los estándares son muy complicados... voy a dejar una lista de elementos generales a cumplir para el estándar de la W3C:

  • Cerrar los elementos que no tienen etiqueta de cierre:
    • Ejemplo:
      • <br> no es estándar
      • <br /> es estándar
      • <meta ...> no es estándar
      • <meta ... /> no es estándar
    • Si bien no es obligatorio, a mi me gusta dejar un espacio antes del cierre ("/").
  • Entrecomillar los atributos
    • Ejemplo:
      • <div class=clase1> no es estándar
      • <div class="clase1"> es estándar
      • <img src=./img/css/icon.png> no es estándar
      • <img src="./img/css/icon.png> tampoco es estándar (falta cerrar el elemento)
      • <img src="./img/css/icon.png" /> es estándar
  • Cumplir los requisitos básicos de las diferentes etiquetas:
    • <head>
      • Tiene que tener el tag "title" dentro
    • <img>
      • Tiene que tener los atributos "src" y "alt"
    • <a>
      • Tiene que tener el atributo "src"
    • <html>
      • Tiene que tener un "charset" definido
    • <form>
      • Tiene que tener los atributos "name", "action" y "method"
    • <input>
      • Tiene que tener el atributo "type" y "name"
    • <ul>, <ol>
      • Tiene que tener el atributo "type"

Creo que no me dejo ningún elemento en el tintero... como veis, no es demasiado complicado cumplir con el W3C (al menos con webs simples o muy poco complejas).

El "problema", por así decirlo, viene cuando programamos en PHP (por ejemplo). El uso de comillas se puede hacer algo caótico, sobretodo si hacemos JavaScript dinámico en el que llamamos a funciones con parámetros en forma de cadena (que va entrecomillada...)

Mi sugerencia: en PHP usad (siempre que podáis) las comillas simples, y los textos entrecomillados usando la doble comilla.

Vale, todo esto es muy bonito, pero, ¿Qué implica al diseño con la W3C? para responder haré una pequeña reflexión:

Continuamente salen nuevos aparatos tecnológicos que implementan, de alguna u otra manera, la tecnología de Internet.

Éstos nuevos dispositivos implementarán unas u otras reglas, y éstas pueden o no paliar una codificación "no estándar".

A continuación hago un ejemplo drástico, para que se vea la diferencia:

 - Si haces un documento así:

<body><table><td>HOLA

y lo probamos en chrome, éste lo estructura internamente así (inspeccionando el elemento):

<html><head></head><body><table><tbody><tr><td>HOLA</td></tr></tbody></table></body></html>

Ahora se ve el cambio... ha puesto de todo. Y esto se debe a que los navegadores no vuelcan el código fuente directamente, sino que lo tratan previamente.

Puede que un nuevo navegador no incluya todo esto, por el motivo que sea (menor consumo de recursos, por ejemplo), y entonces... ¿qué pasaría con nuestra web? estaría a merced de los algoritmos del navegador, y la veríamos de vete-tú-a-saber-qué manera.

Sin embargo, en una web estándar W3C, la conversión que hace el navegador es nula, por lo que nos "da igual" cómo trate el código fuente, siempre (en teoría) se verá igual la web.

Por este motivo siempre intento que las web cumplan el estándar.

Podéis pasar el test aquí:  http://validator.w3.org/

Si pasáis el test, os saldrá un enlace para "colgar una medalla" en vuestra web. Con ella los visitantes sabrán que cumplís el estándar (y podéis "fardar" con ella, jeje ;-) )

La próxima entrada la llenaremos con contenido de "maquetar esqueletos a papel".

¡Hasta la próxima!

Diseño web: compatibilidad máxima

Buenas de nuevo!

Empieza una nueva "serie de entradas", para dar tiempo a la serie de las M!nas...

Como dije, hablaremos de diseño web. Diseño compatible, sobretodo.

Antes de todo, comentar que para nada soy ningúno de esos "gurús del CSS" que son capaces de montar verdaderas obras de arte combinando CSS2 y CSS3, y cosas por el estilo... yo el CSS lo uso para diseñar cosas simples. Las cosas complejas las dejo para PHP, JS, y demás...

Os dejo un índice acerca de esta nueva serie:

  1. W3C
  2. Maquetar el esqueleto a papel
  3. Interpretar estilios como el navegador
    1. File
    2. Inline
    3. Direct
  4. Clases con CSS
    1. Ancho
    2. Alto
    3. Posición x e y
    4. Relative, absolute...
  5. Maquetar el esqueleto con CSS
  6. Tips & tricks
    1. Porcentajes
    2. Agrupar contenido en clases superiores
    3. Inherit, initial u omitir
    4. Contenido "centrado"
    5. Contenido que se "redimensiona"
      1. Fondo
      2. Contenido
    6. Jugar con la transparencia
    7. Efectos "misc"
      1. Scroll modificado
      2. Cajas con borde
      3. Modificar "select"
      4. Scroll "dependiente"
      5. Editar listas
    8. Div vs Span
    9. Compatibilizar con otros navegadores

En principio serán 6 entradas, aunque lo más posible es que la sexta esté en varias partes (ya que tiene mucho contenido).

Intentaré ilustrarlo todo con ejemplos, para que quede más claro.

Así, en la próxima entrada hablaremos de la W3C, o dicho de otra manera, cómo hacer webs "estándar". Para mí, este punto es fundamental, ya que una web que cumpla a rajatabla la W3C dice mucho.

Saludos, y

Hasta la próxima!

Varios - Misc

Buenas!

Hacía tiempo que no escribí nada en el blog... llevo severos retrasos con todos mis proyectos... así que, para no estar demasiado sin hacer una entrada "con chicha", vamos a ver varios temas rápidos.

AJAX Cross-Domain (ACD)

Muchas veces habréis oído aquello de "usar API's", si bien no las habéis usado alguna vez (google maps, google calendar...)

Para aquellos que no sepan qué es una API, decir que es una capa de abstracción creada por programadores para facilitar el uso de herramientas web.

Un ejemplo: quiero poner en un mapa dónde vivo (en mi web). Hace tiempo, yo lo hubiera hecho así:

 - Entro en google
 - Busco google maps
 - Busco mi calle
 - Hago un print de pantalla
 - Coloco la imagen en mi web

Sin embargo, las API permiten que mi web conecte con google, y le puedo especificar dónde vivo (en latitud y longitud) y él se encarga de todo (es decir, delegamos el funcionamiento a google). Yo solo me tengo que preocupar de poner una capa (div) para recibir el mapa y llamar al método correspondiente.

Pues bien, uno de los principales problemas que entraña el uso de una API es el ACD (AJAX Cross-Domain).

¿Qué es el ACD? es un impedimento (una medida de seguridad, más bien propia de IE) que impide que una web cargue datos de un servidor externo, tal como indica la imágen "img1" (en rojo marcada la comunicación interrumpida).

img1
Esto frustra todo amago de comunicación con servidores externos. Sin embargo, las API se usan. ¿Cómo?
Pues hay varios métodos:


  • Proxie transparente: esta medida se basa en modificar el archivo .htaccess, con una regla de reescritura, de manera que podemos convertir algo como "http://miweb.com/api" en "http://apiweb.com". Con esto conseguimos establecer un puente, mediante el cual nosotros llamaremos a "miweb.com/api", y mediante el archivo htaccess, estaremos realmente accediendo a "apiweb.com".
    • Ventajas: funciona bien, y de manera simple
    • Inconvenientes: cada cliente de la API tiene que configurar su htaccess (algunos hostings no dejan).
  • Página ACD: es una web (http://www.ajax-cross-domain.com/) en la que te puedes descargar un src (código fuente) de un programa cgi. Mediante htaccess hacemos que lo interprete como un js, y éste hace de puente para solventar el problema de ACD.
    • Ventajas: configurable, seguro
    • Inconvenientes: necesita aceso a ACD, y no todos los hostings permiten interpretar cgi como js.
  • Envoltura: es el método más usable de todos, ya que no necesita de nada por parte del cliente (eso sí, la API tiene que estar preparada para usar envoltura). El método de la envoltura consiste en incluir la llamada a la API dentro de un elemento <script> en nuestra web. De esta manera, nuestra web hará una llamada a la API, para incluír el contenido al script. El contenido que "se crea" es, ni más ni menos que el resultado de llamar a la API deseada.
    • Ventajas: siempre podremos usarla
    • Inconvenientes: el programador de la API tiene que prepararla, y (que yo sepa) solo se puede mandar datos vía GET.
Y, ¿porqué os comento el problema del ACD? pues porque estuve varias semanas luchando con este problema con una API que me tocó programar en mi trabajo, y finalmente lo conseguí solucionar usando el método de la envoltura (y la consecuente remodelación de la API...).

En la próxima entrada (a no ser que sea sobre M!nas), trataré de solucionar el tema del diseño web, para hacer lo máximo compatible con IE, Firefox, chrome, opera y safari.

Para poder seguir entregando material en abundancia, lo haré tipo "serie", como he estado haciendo estas entradas.



Varios

Buenas de nuevo!

Sigo trabajando en la entrada de las M!nas, aunque llevo algunos retrasos...

La semana pasada estuvo muy movida también... espero que esta semana vuelva todo a la normaildad...

Y bueno, este fin de semana estuve en el salón del manga. Como era de esperar nadie llevaba el mismo cosplay que yo :-p (Prince of persia: Warrior Within, con la Water Sword).

Allí conseguí ponerme en contacto con un novato (y con esto no quiero decir que sea malo) desarrollador de videojuegos, así que quizás en un tiempo me meto en ese mundillo. También cogí información de un centro que forma en 3D (y lo hace muy bien, al parecer); si bien los precios son elevado (9.900€ un máster de 9 meses, 19.800 una carrera de 2 cursos), incluye mucho material (incluyen hasta un ordenador), así como también prácticas en empresa.

También conseguí contactos con editoriales varias... resulta que tengo un relato corto escrito y registrado, pero no consigo que salga a la luz... a ver si con estos nuevos contactos consigo algo.

En cuanto al merch que compramos (mi novia, mi buen amigo James y yo) fue variado, aunque este año no hemos encontrado ninguna ganga (el año pasado conseguimos una figura de Bobobo por 20€ - en los otros stands las vendían por 80€).

En cuanto a últimas novedades, estoy metido en un concurso de InfoJobs, que consiste en desarrollar una App para la misma compañía, usando su API. El premio al ganador oscila entre los 10.000 y 12.000€ (así que si - ojalá - ganara sería una buena alegría). Pienso que mi idea es buena; y esto es un buen comienzo, ya que hace falta mucha motivación para hacer algo bueno y decente, y sin una buena autoestima es imposible!

Antes de cerrar esta entrada, decir que me guardo las fotos del Salón del Manga (así como las del anterior) para una posible futura entrada no relacionada con  la informática (como esta, jejeje).

Saludos y...

¡Hasta la próxima!

A buscar M!nas: MSAccess - ampliando VB.net

Buenas otra vez!

Me he pasado el finde descansando y vagueando, que ya tocaba! (13/10/12)

Pero hoy es lunes, así que volvemos a la carga con el blog. Además empezamos la parte de programación.

En esta entrada ampliaremos el juego, usando ADO.net.

ADO.net

ADO.net es un objeto que el ".net" provee, con la función de conectar a las bases de datos sin demasiadas dificultades.

Por así decirlo, crea una capa extra entre el motor de la base de datos y la aplicación .net (así como hicimos con Java hace tiempo, pero de manera nativa).

Hay una serie de objetos que segregan de la utilización de ADO, que son:

  • OleDbConnection: provee la conexión
  • OleDbCommand: contiene sentencias SQL, sirve para lanzarlas
  • OleDbDataReader: se usa para obtener los datos de las sentencias.

Una visualización de ejemplo: supongamos que al iniciar el juego de VB.net, éste conecta con la base de datos y ejecuta un SQL. El esquema sería algo así como indica la img1

img1

El evento onLoad tiene su recorrido en naranja: así, se puede ver cómo, usando los objetos de ADO.net accedemos a la base de datos, y extraemos datos, los cuales serán tratados con OleDbDataReader.

Haciendo un símil con PHP, el OleDbCommand equivaldría al mysq_query(), mientras que el OleDbDataReader equivaldría al mysq_fetch_array().


Diseño de consultas

El siguiente paso es diseñar todas las consultas que nos pudieran hacer falta. Aquí enumeraré unas cuantas imprescindibles:


  • Comprobar si existe un usuario
  • Crear un nuevo usuario
  • Insertar un registro
Tal como quedó el modelo relacional, definiríamos las sentencias así:

  • select count(*) from usuario where nick='';
  • insert into email(email) values(''); insert into usuario(nick, nombre, apellido1, apellido2, idE, password) values('', '', '', '', select max(idE) from email, '');
  • insert into estadistica(gana, tiempo, dificultad, opcion, autenticacion, minas, clicks) values('', '', '', '', '', '', '', ''); insert into juego(nick, id_estadistica, fecha) values('', select max(id_estadistica) from estadistica, '');

Desde luego estas consultas son las realmente básicas. No he puesto ningún dato porque de momento aún tenemos que ver cómo rellenaremos estas sentencias.

NOTA: cometí un error (como no...) cuando describía las tablas: la columna "minas" sirve para almacenar el número de minas que el usuario tenía marcadas cuando el juego terminó.

Hacer que funcione

El último paso antes de finalizar esta entrada es conectar todo; tenemos el MSAccess, el VB.net y el ADO.net. Es el momento de conectarlo todo!

Para ello, el objeto OleDbConnection necesita lo que se denomina "cadena de conexión". Ésta es un String que contiene información parametrizada sobre cómo y con qué conectará el objeto.

La cadena de conexión de ADO.net para MSAccess es la siguiente:

Provider=Microsoft.ACE.OLEDB.12.0;Data Source=SRC;Persist Security Info=False;

Las partes en negrita son variables. SRC indica la ruta física donde está la base de datos, y False indica si la conexión ha de ser persistente (por defecto siempre a false con MSAccess).

Ahora abrimos nuestro proyecto de VB.net, y añadimos las siguientes líneas en BX_module:

    Public con As OleDbConnection
    Public cn As String = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=" + Application.StartupPath + "\BuscaminaX.accdb;Persist Security Info=False;"
    Public cmd As OleDbCommand

Aquí definimos los dos objetos fijos que usaremos para tratar nuestra base de datos. Dos anotaciones: seguramente tendréis que importar el dominio System.Data.OleDb. Para ello escribid al comienzo del módulo:

"Imports System.Data.OleDb"

Por otra parte, tenéis que copiar la base de datos "BuscaminaX" a la carpeta de la aplicación ("/bin/debug").

El siguiente paso es definir tres funciones globales para nuestra aplicación:

  • Una función de conexión
  • Una función de ejecución de SQL (insert, update, delete)
  • Una función de consulta SQL (select)
Las podemos definir así:

#Region "SQL FUNCTIONS"
    Public Sub Conectar()
        BX_module.con = New OleDbConnection(cn)
    End Sub

    Public Sub Lanzar(ByVal sql As String, ByRef r As OleDbDataReader)
        BX_module.con.Open()
        cmd = New OleDbCommand(sql, BX_module.con)
        r = cmd.ExecuteReader()
    End Sub

    Public Sub Ejecutar(ByVal sql As String)
        Dim command As New OleDbCommand(sql, con)

        Try
            command.Connection.Open()
        Catch ex As Exception
        End Try

        command.ExecuteNonQuery()
        command.Connection.Close()
        command.Dispose()
        command = Nothing

        con.Close()
    End Sub
#End Region

Vamos a analizar un poco el código:

 - Conectar() instancia un nuevo OleDbConnection usando la cadena de conexión "cn".

 - Lanzar(sql, r) abre la conexión, instancia un nuevo OleDbCommand con "sql" y "con", y rellena "r". Nótese que para que los cambios en "r" sean persistentes, pasamos la variable por referencia ("ByRef") y no por valor ("ByVal")

 - Ejecutar(sql) crea un nuevo OleDbCommand (ya que luego será destruído), y ejecuta la sentencia SQL pasada.

Para leer los datos que devuelve lanzar debemos hacer algo similar a PHP (por ejemplo). Concretamente:


Lanzar(ret, r)

Do While r.Read
    'cosas. Se accede por "r(n)", donde n es un entero mayor o igual que 0
 Loop

con.Close()

Y así es cómo accedemos a los datos desde VB.net.

El siguiente paso es hacer un sistema de registro para cuando empieza el juego. También (después) crearemos una pantalla con estadísticas.

Para la pantalla de inicio de sesión, crearemos una nueva "SplashScreen". La llamaremos "LogIn.vb". De nuevo la preparamos borrando todo el contenido, y colocamos varios campos rellenables; tal que así:

img2
Ahora debemos esquematizar la comprobación de datos. Para ello haremos lo siguiente, teniendo en cuenta que un usuario anónimo no tendrá password, mientras que uno registrado sí; y tomando como supuesto que el usuario pulse "next" (el otro caso lo vemos ahora)










SI nick NO vacío
    recoges datos de DB
SINO
    error
FIN

SI datos(pass) NO vacío
    SI pass vacío
       error
    SINO
        SI datos(pass) = pass
            ok!
        SINO
           error
    FIN
SINO
    ok!
FIN    

Se puede ver una gran cantidad de "IF". Ahora os explicaré lo que yo llamo "filtrar por return". Esta técnica quizás no sirva para acortar demasiado el código, pero sirve para evitar tantas identaciones.

El sistema es el siguiente: se supone el "peor" caso. Si se cumple salimos, sin más (terminamos el sub, retornamos un valor de control...).

En la siguiente línea, ya tenemos controlado el caso, por tanto no hace falta un "ELSE".

Aplicando este concepto, podemos hacer:

SI nick vacío
    error(SALIR)
FIN

SI datos(pass) NO vacío
  SI pass vacío
    error(SALIR)
  FIN
SINO
  SI datos(pass) NO = pass
    error
   FIN
FIN

sigue

El siguiente caso a contemplar es el de crear un nuevo usuario. Para ello los pasos a seguir son:

 - Comprobar si todos los datos están introducidos
 - En caso que lo estén, comprobar si existe el usuario registrado
 - En caso que no exista, introducimos los datos.

Crearemos dos funciones principales para sendas tareas. Podrían ser algo así:

#Region "LogIn"
    Public Function nextStep() As Boolean
        Dim r As OleDbDataReader
        Dim pass As String

        If LogIn.TextBox1.Text.Length = 0 Then
            Return False
        End If

        BX_module.Conectar()
        Lanzar("select nick, password from usuario where nick ='" + LogIn.TextBox1.Text.ToString + "'", r)
        r.Read()

        Try
            pass = r(1)
        Catch ex As Exception
            pass = ""
        End Try

        BX_module.con.Close()

        If pass <> "" Then
            If LogIn.TextBox2.Text.ToString = "" Then
                Return False
            ElseIf LogIn.TextBox2.Text.ToString <> pass Then
                Return False
            End If
        Else
            If pass <> LogIn.TextBox2.Text.ToString Then
                Return False
            End If
        End If

        Return True
    End Function

    Public Function newUser() As Boolean
        Dim r As OleDbDataReader
        Dim cont As Integer
        Dim idE As Integer

        If LogIn.TextBox3.Text = "" Or _
           LogIn.TextBox4.Text = "" Or _
           LogIn.TextBox5.Text = "" Or _
           LogIn.TextBox6.Text = "" Or _
           LogIn.TextBox7.Text = "" Then
            Return False
        End If

        BX_module.Conectar()
        Lanzar("select count(*) from usuario where nick ='" + LogIn.TextBox4.Text.ToString + "' and idE = (select idE from email where email = '" + LogIn.TextBox5.Text.ToString + "')", r)
        r.Read()

        Try
            cont = r(0)
        Catch ex As Exception
            cont = 0
        End Try

        BX_module.con.Close()

        If cont <> 0 Then
            Return False
        End If

        BX_module.Conectar()
        Lanzar("select max(idE) from email", r)
        r.Read()

        Try
            idE = r(0) + 1
        Catch ex As Exception
            idE = 1
        End Try

        BX_module.con.Close()
        Ejecutar("insert into email(idE, email) values(" + idE.ToString + ", '" + LogIn.TextBox5.Text.ToString + "')")
        BX_module.Conectar()
        Lanzar("select idE from email where email = '" + LogIn.TextBox5.Text.ToString + "'", r)
        r.Read()
        Ejecutar("insert into usuario([nick], [nombre], [apellido1], [apellido2], [idE], [password]) values('" + LogIn.TextBox4.Text.ToString + "', '" + LogIn.TextBox6.Text.ToString + "', '" + LogIn.TextBox7.Text.ToString + "', '" + LogIn.TextBox8.Text.ToString + "', " + r(0).ToString + ", '" + LogIn.TextBox3.Text.ToString + "')")
        BX_module.con.Close()
        Return True
    End Function
#End Region

Ahora viene enlazar los valores de retorno al módulo principal. Esto lo haremos en dos partes, de manera que:

 - Crearemos una variable pública en LogIn.vb, de manera que el resultado de la función se guardará ahí.
 - Mientras la variable anterior sea "false", mostraremos la pantalla principal.

Esto lo hacemos así:

a) LogIn.vb

    Public hand As Boolean = False

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        Me.hand = BX_module.nextStep()
    End Sub

    Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
        Me.hand = BX_module.newUser()
    End Sub


b) BuscaminaX.vb -> BuscaminaX_onLoad

        Do
            LogIn.ShowDialog()
        Loop Until LogIn.hand


Con esto damos por terminada la parte de Programación en VB.net

Así, en la próxima entrada trataremos la gestión de consultas desde MSAccess.

Pido disculpas por la tardanza; repito que estuve MUY liado.

Espero poder seguir escribiendo más a menudo!

Saludos y,

¡Hasta la próxima!