A la hora de poner un encabezado o pie de página en Word, por ejemplo para numerar páginas con un formato propio, se pueden poner comodines para que el texto de cada página dentro de una misma sección se adapte a cada página (y si están enlazadas secciones, las secciones comparten el mismo formato).

Para ello están los códigos de campo.

Para insertar un código de campo en un encabezado, pie de página, etiqueta, carta modelo, etc,… hay que presionar Control + F9, lo que hará que aparezca un bloque especial “{}” (este bloque no se puede crear escribiendo las llaves) y dentro de dichas llaves se podrán utilizar los códigos/comandos.

Es posible que hayamos insertado la numeración de página mediante la opción del menú “Insertar” o similar. Para poder ver los códigos de campo, hay que estar en modo “ver encabezado/pie de página” y presionar Alt+F9.

Códigos interesantes son:

{ NUMPAGES }

Indica el número de páginas del documentos

{ PAGE }

Indica la página actual dentro de la sección.

{= }

Permite computar, como en excel. Por ejemplo:  {= { PAGE } + 1}

Para más información,  mirar la Referencia de Campo disponible en Microsoft para el Office.

Lo más probable es que buscando cómo ocultar las caras de los polígonos que no están orientados hacia nosotros en Processing, se llege a la página http://wiki.processing.org/w/Backface_culling; curiosa página que no resuelve la duda, ya que indica que “se puede activar” pero no indica cómo.

Una parte de la solución está en la página, en la sección de tutoriales en la misma wiki, de “OpenGL Avanzado”: http://wiki.processing.org/w/Advanced_OpenGL

La solución, para que no haya que pensar mucho, es esta:

import processing.opengl.*;
import javax.media.opengl.*; // Para backface culling
GL gl;

void setup() {
  size(200,200,OPENGL);
  gl = ((PGraphicsOpenGL)g).beginGL();
  gl.glEnable(GL.GL_CULL_FACE);
  gl.glCullFace(GL.GL_FRONT);
}

void draw()  {
}

Para activar y desactivar el backface culling se utiliza:

  gl.glEnable(GL.GL_CULL_FACE);
  gl.glDisable(GL.GL_CULL_FACE);

Para cambiar el tipo de ocultación entre la cara frontal y la trasera:

  gl.glCullFace(GL.GL_FRONT);
  gl.glCullFace(GL.GL_BACK);

ATENCIÓN: por experiencia propia, Processing parece no funcionar bien como mínimo con texturas porque cambia el orden de dibujado de vértices, lo que hace que la cara frontal o trasera no pueda ser definida al gusto personal. Es decir, la frontal y la trasera, mágicamente, siempre es la misma :(

En el lenguaje Processing, los ejes X, Y y Z son los siguientes con el centro de coordenadas en la esquina superior izquierda de la pantalla:

• X positiva hacia la derecha
• Y positiva hacia abajo
• Z positiva hacia fuera de la pantalla

A menudo se me olvida el sentido de la Z, así que aquí pongo una imagen extraída de este tutorial, en la que se indica el sentido de -Z:

Y añado este programa:

import processing.opengl.*;

size(200,200,OPENGL) ;

fill(0,0,255) ;
rect(50,50,100,100) ;

pushMatrix() ;
  translate(100,100,-50);
  fill(0,255,0) ;
  box(40) ;
popMatrix() ;

pushMatrix() ;
  translate(100,100,50) ;
  fill(255,0,0) ;
  box(40) ;
popMatrix() ;

Este programa dibuja un rectángulo azul como base en Z=0, un cubo verde en la coordenada Z=-50 , y un cubo rojo en la coordenada Z=50 . El cubo rojo es el que se ve, por lo tanto, la Z positiva “hacia fuera del monitor”.

La explicación más aclaratoria es: en processing el producto vectorial de X por Y es -Z (se puede ver según la regla de la mano derecha).

Espero que ahora no se me vuelva a olvidar…

Para ajustar el monitor LCD (en concreto, en mi caso es TFT) conectado a la salida analógica y que cada pixel sea un único pixel lo mejor es utilizar el patrón en forma de cuadrados de ajedrez de esta página: http://www.techmind.org/lcd/phasing.html

Cargar la página, ponerla a pantalla completa con F11 y pulsar el botón de autoajustar del monitor. Después terminar de ajustar un poco a mano. En uno de mis monitores no hizo falta ajustar a mano, y en el otro sólo cambiar un poquito los parámetros hasta que se vió perfectamente el patrón en forma de cuadrados de ajedrez.

Ahora las contraseñas de usuarios del servidor Apache2 se almacenan encriptadas mediante SHA1. La versión del módulo que viene con la distribución es la 4.3.9-11 y es complicado configurarla (yo no conseguí que aceptase SHA1).
La solución ha sido instalar el paquete de Ubuntu Lucid: http://ns2.canonical.com/es/lucid/web/libapache2-mod-auth-mysql que es la versión 4.3.9-12

Después simplemente se trata de activar el módulo (con sudo en caso necesario,…):
$ a2enmod auth_mysql
y leer detenidamente las instrucciones que aparecen en:
/usr/share/doc/libapache2-mod-auth-mysql/USAGE.gz
/usr/share/doc/libapache2-mod-auth-mysql/DIRECTIVES.gz

Sencillo sencillo.