Jonas' Blog

¿Os acordáis de de la aplicación MSDN Video, aquella que se desarrolló para dar a conocer la tecnología .Net allá por el 2003? Pues bien, desde hace un tiempo sabía que estaban actualizando el contenido para adaptarlo al framework 3.5 y Visual Studio 2008, lo que me parecía algo estupendo. Pues bien, anoche antes de acostarme decidí dar un paseo por la web de desarrolla con MSDN y sorpresa la mía al encontrarme que ya han publicado MSDN Video 2008.
 

Esta vez las tecnologías de las que se harán uso son, entre otras, Ajax, Linq, WPF y WCF. Se pretende que sea un proyecto en constante evolución, en el cual cada uno de nosotros podemos aportar nuestro granito de arena. El código fuente del que tenemos disponibilidad es una versión beta y también disponemos de un primer video de introducción en Silverlight. A parte, parece que sacarán un curso online para aprender el modo en el que se han utilizado las nuevas tecnologías que incorpora el framework 3.5.

Espero que os resulte útil, un saludo.

No se si a alguno de vosotros os habrá pasado, pero para mi instalar Visual Studio 2008 se ha convertido en una odisea y después de varios intentos he conseguido realizar una instalación satisfactoria.

Primer punto a tener en cuenta y, como suele ser habitual... antes de instalar un nuevo programa es recomendable desinstalar las betas o directamente el programa  de instalación te avisa de que antes de instalar una nueva versión tienes que instalar las betas que tengas en tu máquina.

Partimos de que mi sistema operativo es un Vista Business con VS2005, SQL Server 2005, Office 2007 entre otros y que antes de instalar Visual Studio 2008 tenia instalada la beta 2. VS2008 no va a ser distinto a cualquier otro programa y al intentar instalarlo sobre alguna pre-release os saldrá un cuadro de dialogo indicando que desinstaleis un determinado numero de componentes (ver imagen inferior). Existe una lista y un orden en el que desinstalar esos productos que podéis visitar aquí pero no todos los componentes que tendrás que desinstalar tienen que aparecer en esa lista, por ejemplo, los componentes que a mi me pedía desinstalar no aparecen en esa lista.

Puede ser que desinstales los componentes que os aparezcan en el cuadro de dialogo anterior y que al reiniciar la instalación os vuelva a pedir que desinstaleis otros componentes. De hecho al segundo intento me pidió desinstalar los siguientes hotfixes desde windows update: (KB110806), (KB930264) y (KB929300). Bueno... esto puede ser un poco tortuoso: intentar instalar, desinstalar componentes, volver a instalar... pero esto no es lo más frustrante, ¿qué ocurre cuando quieres desinstalar un componente que aparentemente no tienes instalado? te diriges a Panel de control -> Programas y características y ese componente no aparece en el listado de programas instalados. Por lo visto, esta herramienta te muestra como programas instalados los que quiere.
Una posible solución es irte al registro y borrar las entradas a mano, algo poco recomendable y otra opción es desinstalar esos componentes con la herramienta  Windows Installer Clean Up. Con esta herramienta podréis desinstalar todos componentes necesarios para poder instalar VS2008.

Una vez desinstalados todos los malditos componentes que me daban problemas pude iniciar la instalación de VS2008 pero otro problema que encontré fue que, a mitad de la instalación, ésta producía un error y terminaba. Lo que se me ocurrió fue desinstalar Office 2007 porque ya había oído que daba problemas cuando se intenta instalar algún programa teniéndolo instalado. Después de esto si, por fin tenia instalado VS en mi portátil como se puede ver en la imagen!!

Aunque tengo que decir... que no todo fueron alegrías. Al crear un nuevo proyecto, ya fuera web, wpf o windows form, VS producía un error y no cargaba el diseñador gráfico. La forma en que resolví este problema, y con este el ultimo, fue instalar las actualizaciones que podemos encontrar en el DVD de VS2008 en la carpeta: WCU\dotNetFramework\dotNetMSP\x86.

Con todo esto conseguí instalar VS2008 y tener un funcionamiento correcto, así que si alguno de vosotros instala VS2008 y tiene alguno de estos problemas, espero que os sean útiles los pasos que yo he seguido para solucionar los problemas que me han ido surgiendo.

Hace unos cuantos unos (bueno, unas semanas... que no encuentro tiempo para postear!!) necesitaba imprimir unos datos que se encontraban en un formulario y lo lógico sería usar reportes para hacerlo, pero por la falta de tiempo y por no haber trabajado reportes antes necesitaba una solución más rápida, entonces se me ocurrió imprimir el formulario y buscando por la red encontré este artículo en la knowledge base de Microsoft.  Pues bien, en primer lugar lo que hice fue pasar ese código a  C# y segundo hacer unas pequeñas variaciones al código para que la impresión del formulario se ajustara más a lo que deseaba. Para probarlo nos creamos un nuevo proyecto para una aplicación windows (en C#) y añadimos la siguiente clase al proyecto (extraída del articulo anterior):

using System;

using System.Collections.Generic;

using System.Text;

using System.Drawing.Printing;

using System.Drawing;

using System.Drawing.Drawing2D;

using System.Drawing.Imaging;

using System.Runtime.InteropServices;

public class Win32APICall

{

    public const int DIB_RGB_COLORS = 0;

    public const int BI_RGB = 0;

    public const int WHITENESS = 16711778;

    [DllImport("user32.dll", EntryPoint = "PrintWindow", SetLastError = true,

        CharSet = CharSet.Unicode, ExactSpelling = true, CallingConvention =

        CallingConvention.StdCall)]

    public static extern UInt32 PrintWindow(IntPtr hWnd, IntPtr hDC, int dwFlags);

    [DllImport("gdi32.dll", EntryPoint = "CreateDIBSection", SetLastError = true,

        CharSet = CharSet.Unicode, ExactSpelling = true, CallingConvention =

        CallingConvention.StdCall)]

    public static extern IntPtr CreateDIBSection(IntPtr hdc, ref BITMAPINFOHEADER pbmi,

        Int32 iUsage, IntPtr ppvBits, IntPtr hSection, Int32 dwOffset);

    [DllImport("gdi32.dll", EntryPoint = "PatBlt", SetLastError = true, CharSet =

        CharSet.Unicode, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]

    public static extern bool PatBlt(IntPtr hDC, Int32 nXLeft, Int32 nYLeft, Int32 nWidth,

        Int32 nHeight, Int32 dwRop);

    [DllImport("gdi32.dll", EntryPoint = "SelectObject", SetLastError = true,

        CharSet = CharSet.Unicode, ExactSpelling = true, CallingConvention =

        CallingConvention.StdCall)]

    public static extern IntPtr SelectObject(IntPtr hDC, IntPtr hObj);

    [DllImport("GDI32.dll", EntryPoint = "CreateCompatibleDC", SetLastError = true,

        CharSet = CharSet.Unicode, ExactSpelling = true, CallingConvention =

        CallingConvention.StdCall)]

    public static extern IntPtr CreateCompatibleDC(IntPtr hRefDC);

    [DllImport("GDI32.dll", EntryPoint = "DeleteDC", SetLastError = true,

        CharSet = CharSet.Unicode, ExactSpelling = true, CallingConvention =

        CallingConvention.StdCall)]

    public static extern bool DeleteDC(IntPtr hDC);

    [DllImport("GDI32.dll", EntryPoint = "DeleteObject", SetLastError = true,

        CharSet = CharSet.Unicode, ExactSpelling = true, CallingConvention =

        CallingConvention.StdCall)]

    public static extern bool DeleteObject(IntPtr hObj);

    [DllImport("User32.dll", EntryPoint = "ReleaseDC", SetLastError = true,

        CharSet = CharSet.Unicode, ExactSpelling = true, CallingConvention =

        CallingConvention.StdCall)]

    public static extern bool ReleaseDC(IntPtr hWnd, IntPtr hDC);

    [DllImport("User32.dll", EntryPoint = "GetDC", SetLastError = true,

        CharSet = CharSet.Unicode, ExactSpelling = true, CallingConvention =

        CallingConvention.StdCall)]

    public static extern IntPtr GetDC(IntPtr hWnd);

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]

    public struct BITMAPINFOHEADER

    {

        public Int32 biSize;

        public Int32 biWidth;

        public Int32 biHeight;

        public Int16 biPlanes;

        public Int16 biBitCount;

        public Int32 biCompression;

        public Int32 biSizeImage;

        public Int32 biXPelsPerMeter;

        public Int32 biYPelsPerMeter;

        public Int32 biClrUsed;

        public Int32 biClrImportant;

    }

Ahora diseñamos el formulario que queremos imprimir y le añadimos un objeto PrintDocument printDocument1 y PrintDialog printDialog1, nos puede quedar algo como esto, un formulario que muestre información sobre libros (si, ya se que es feo, pero para el propósito que tiene es suficiente):

Después tendríamos que controlar el evento click del botón imprimir para que cuando pulsemos en el boton se imprima el formulario y a parte, tenemos que añadir a nuestro código el método que se encargará de imprimir el formulario (también extraído del articulo del que he hablado más arriba) llamado OnPrintPage:

private void buttonImprimir_Click(object sender, EventArgs e)

{

    printDialog1.Document = printDocument1;

    if ((printDialog1.ShowDialog() == DialogResult.OK))

    {

        printDocument1.PrintPage += new PrintPageEventHandler(this.OnPrintPage);

        printDocument1.Print();

    }

Bien con esto ya podemos imprimir nuestro formulario, sencillo, pero vamos a ir un poquito más allá, la verdad es que imprimir el formulario así tal cual puede quedar un poquito feo, entonces lo que podemos hacer es modificar la apariencia del formulario para que se imprima lo que nosotros queramos que se vea. Para eso solo tenemos que cambiar la apariencia antes de imprimir el formulario y después de realizar la impresión devolver al formulario su apariencia original. Para el formulario que hemos creado podríamos, por ejemplo, ocultar el botón de impresión, el marco de la ventana, eliminar el borde de los textboxs y cambiar el color de fondo. El código final para el método buttonImprimir_Click sería:

private void buttonImprimir_Click(object sender, EventArgs e)

{

    Color colorFondo = this.BackColor;

    try

    {

        printDialog1.Document = printDocument1;

        if ((printDialog1.ShowDialog() == DialogResult.OK))

        {

            // ocultamos el borde del formulario

            this.FormBorderStyle = FormBorderStyle.None;

            //cambiamos el color de fondo del formulario

            this.BackColor = Color.White;

            //quitamos el borde a los texbox

            textBox1.BorderStyle = BorderStyle.None;

            textBox2.BorderStyle = BorderStyle.None;

            textBox3.BorderStyle = BorderStyle.None;

            textBox4.BorderStyle = BorderStyle.None;

            textBox5.BorderStyle = BorderStyle.None;

            textBox6.BorderStyle = BorderStyle.None;

            //ocultamos el boton de imprimir

            buttonImprimir.Visible = false;

            printDocument1.PrintPage += new PrintPageEventHandler(this.OnPrintPage);

            printDocument1.Print();

        }

    }

    catch (Exception)

    {

        MessageBox.Show("Error al imprimir", "Error",

            MessageBoxButtons.OK, MessageBoxIcon.Error);

    }

    finally

    {

        //restauramos las propiedades de los controles

        this.FormBorderStyle = FormBorderStyle.Sizable;

        this.BackColor = colorFondo;

        textBox1.BorderStyle = BorderStyle.FixedSingle;

        textBox2.BorderStyle = BorderStyle.FixedSingle;

        textBox3.BorderStyle = BorderStyle.FixedSingle;

        textBox4.BorderStyle = BorderStyle.FixedSingle;

        textBox5.BorderStyle = BorderStyle.FixedSingle;

        textBox6.BorderStyle = BorderStyle.FixedSingle;

        buttonImprimir.Visible = true;

        //refrescamos el form

        this.Refresh();

    }

}

Y por si quereis trastear con el código os lo dejo adjunto más abajo, un saludo!!!

Siguiendo en la linea del post anterior, vamos a comentar dos de los puntos que fueron mencionados, los problemas con operaciones aritméticas y de comparación que, aunque de conocimiento básico no viene nada mal recordar.
 

- Operaciones aritméticas. Supongamos que tenemos un determinado objeto, como pueda ser una imagen, que tiene dimensiones (ancho y alto) y que queremos redimensionarla de tal forma que necesitamos obtener los porcentajes en que se redimensionan para el ancho (width) y alto (height), pues basta con dividir las nuevas dimensiones por las originales:

//valores de ejemplo

int widthOrigen = 2698;

int heightOrigen = 1780;

int width = 1024;

int height = 768;

 

float porcentajeW, porcentajeH;

 

porcentajeW = (width / widthOrigen);

porcentajeH = (height / heightOrigen);

pero este código no es del todo correcto porque lo que se produce es una división de enteros, por lo que el resultado será un entero aunque luego lo almacenemos en un float, para que el resultado de la división sea correcto bastaría con hacer un casting de uno de los operandos, posteriormente el compilador "promociona" el valor de menor precisión al del tipo de mayor precisión, es decir, de int a float:

porcentajeW = (width / (float)widthOrigen);

porcentajeH = (height / (float)heightOrigen);

- Operaciones de comparación. Esto es algo básico en la programación orientada a objetos, si intentamos comparar dos objetos con el operador de comparación (==) pues no obtendremos el resultado deseado porque lo que hacemos es comparar sus referencias a memoria, solo es válido para los tipos básicos(int, float, string...). Para comparar objetos podemos y/o debemos usar el método Equals(object obj), pero no basta con hacer una llamada a este método, pues obtendríamos el mismo resultado que al usar el operador de comparación. Este método pertenece a la clase object y debe ser sobrescrito en nuestras clases para que compare dos objetos de forma correcta. Supongamos que tenemos una clase llamada Complejo como la siguiente:

public class Complejo

{

    public int a;

    public int b;

 

    public Complejo(int a, int b)

    {

        this.a = a;

        this.b = b;

    }

 

    //...

 

    public override bool Equals(object obj)

    {

        try

        {

            Complejo aux = (Complejo)obj;

 

            if (this.a == aux.a)

                if (this.b == aux.b)

                    return true;

        }

        catch (InvalidCastException)

        {

            // es un objeto de otro tipo

        }

 

        return false;

    } 

}

Podemos destacar el método Equals(object obj), que no tiene ninguna complejidad, el cual se encarga de sobrescribir la forma predeterminada de comparar dos objetos de tipo Complejo. Al compilar, obtendremos una advertencia por no sobrescribir el método GetHashCode() así que o lo sobrescribís o pasáis de la advertencia. Por último y para ver la diferencia entre una simple comparación y el método Equals() lo mejor es verlo con un ejemplo:

Complejo c1 = new Complejo(2, 5);

Complejo c2 = new Complejo(2, 5);

Complejo c3 = c1;

Console.WriteLine("c1 = c2: " + (c1 == c2));

Console.WriteLine("c1 = c3: " + (c1 == c3));

Console.WriteLine("c2 = c3: " + (c2 == c3));

Console.WriteLine("c1.Equals(c2): " + c1.Equals(c2));

Console.WriteLine("c1.Equals(c3): " + c1.Equals(c3));

Console.WriteLine("c2.Equals(c3): " + c2.Equals(c3));

c3.a = 7;

Console.WriteLine("c1 = c2: " + (c1 == c2));

Console.WriteLine("c1 = c3: " + (c1 == c3));

Console.WriteLine("c2 = c3: " + (c2 == c3));

Console.WriteLine("c1.Equals(c2): " + c1.Equals(c2));

Console.WriteLine("c1.Equals(c3): " + c1.Equals(c3));

Console.WriteLine("c2.Equals(c3): " + c2.Equals(c3));

¿Cuál es el resultado?

Muchas veces cometemos errores que se podrían evitar simplemente prestando un poquito más de atención. Aquí van una serie de errores que podemos cometer con cierta asiduidad, desde mi punto de vista, y que podríamos minimizar con un poco de atención:

- Copy/paste: es muy habitual copiar partes de código que pueden repetirse, por ejemplo, de un método a otro y al que  después le realizamos alguna pequeña modificación. Sobre esta base, empezamos a modificar dicho código y de una idea vamos a otra que a su vez nos conduce a otra, que hace que nos olvidemos de la primera idea y de quitar esas linea de código que esta vez nos resultan inútiles. Hay estudios que afirman que las personas no pueden realizar más de 7 tareas a la vez, ¿será verdad?

- Aritmética: las prisas, que no son nada buenas pueden llevarnos a cometer errores en las operaciones aritméticas  pues podemos pasar por alto realizar algún casting necesario con el que sin él, obtendríamos un resultado diferente al esperado.

- Caracteres especiales: hay que tener especial cuidado al escribir código que haga uso de caracteres especiales. Estas escribiendo una capa de acceso a datos para una base de datos cuando haces un ... LIKE '*algo*'... y la consulta select no devuelve los datos esperados... ¿estás seguro de que ese carácter especial para indicar una cadena de uno o más caracteres es *?¿y si es %, o cualquier otro? no está de más dar un vistazo rápido a la referencia de la bbdd con la que se está trabajando.

- Comparación de objetos: no es lo mismo hacer una comparación ( == ) que hacer un objecet.Equals(otroObject), el  resultado producido puede no ser el deseado de nuevo.

- Error de sintaxis: posiblemente con mayor incidencia en C# o Java que en VB puesto que éste último no es Case Sensitive, ¿a quién no se le olvida poner una coma? ¿o poner una palabra en minúscula cuando su primera letra es mayúscula? escribir una palabra de forma correcta... por el amor de Dios!! si llevamos ¿20? ¿30? ¿40...? años escribiendo y hablando nuestra lengua materna, como es el castellano en mi caso, y seguimos cometiendo faltas de ortografía... cómo no las vamos a cometer cuando pikamos código!!!

Éstos son algunos errores habituales (tomados con algo de humor) a la hora de programar, si ahora mismo os viene alguno más a la mente dejarlo caer por aquí y... ¡¡cuidado al pikar código!!!

Haciendo referencia al post que ha publicado Thempra hoy mismo, os dejo una serie de enlaces con recursos para Windows Server 2008 de los que he sabido no hace mucho, espero que os sean útlies:

 http://blogs.technet.com/davidcervigon/archive/2007/09/27/cursos-online-y-libros-gratuitos-de-windows-server-2008.aspx 

http://blogs.technet.com/davidcervigon/archive/2007/09/25/como-instalar-windows-server-virtualization-en-la-rc0-de-windows-server-2008.aspx

http://blogs.technet.com/davidcervigon/archive/2007/09/21/como-conseguir-betas-y-productos-de-evaluacion.aspx

Imaginemos que desarrollamos una nueva aplicación en .Net y queremos que esta compruebe la existencia de un framework para .Net ya que sería un poquito feo que al instalar o ejecutar la aplicación diera un error por no disponer de un framework instalado y que no diera una alternativa a dicho suceso.
 

Si nuestra aplicación va a ser desplegada mediante un paquete de instalación, tipo ClickOnce, es fácil saber si esta instalado un determinado framework, podemos obtener más información en el siguiente enlace o en este otro con información para el Framework 3.0.
 

Pero... ¿y si lo qué queremos es distribuir directamente el fichero ejecutable? por ejemplo mediante un CD-Rom, pues tendremos que determinar de alguna forma la existencia o no del Framework .Net y como es evidente no podemos comprobarlo desde .Net. Una forma sería crear una aplicación que hiciera de lanzadera o launcher (en C/C++, VB...) para nuestra aplicación desarrollada en .Net. Otra forma posible, y a la vez sencilla, es comprobar mediante un script si tenemos instalado o no el framework en nuestra máquina.
 

Windows da soporte a lenguajes de script (JScrip o VBScript) mediante WSH (Windows Scripting Host o Windows Script Host) que viene instalado por defecto desde Windows 98 e Internet Explorer 5. WSH lo que nos permite es realizar scripts para la automatización de tareas, algo que seguro los administradores de sistemas Windows habrán agradecido en cierta medida.
 

Volviendo a lo que estamos tratando en este post, para poder comprobar la existencia del framework utilizaremos un script que comprueba si existen una/s determinada/s clave/s en el registro de Windows que hace/n referencia al Framework .Net y sus distintas versiones. En el siguiente enlace tenemos información detallada de qué claves hacen referencia a cada una de las versiones
del .Net Framework desde la versión 1.0 a la 3.5 y como podemos trabajar con ellas desde código manejado. Particularmente, yo accederé a la clave que hace referencia al Framework 2.0:
 

HKLM\Software\Microsoft\NET Framework Setup\NDP\v2.0.50727\Install
 

Y el código del script en VBScript (nombre.vbs) es el siguiente:

Bien, en la primera linea declaramos un objeto de tipo WScript.Shell, este objeto aporta funciones para obtener información acerca de las características del sistema y de las variables del entorno, así como trabajar con el registro, que es lo que hacemos más abajo, y con accesos directos. Después, dependiendo de si el valor devuelto al leer el registro es 1 ó 0, se ejecutará nuestra aplicación o tendremos una alternativa para hacer otras cosas como instalar un framework. El script es un ejemplo, pero podríais hacerlo tan complejo como sea necesario.
 

Enlaces que pueden resultar de interés:

WSH Primer On Microsoft TechNet

Manual en castellano para WSH

Scripting en MSDN

El equipo del Instituto Politécnico Rensselaer ha desarrollado una pila poco más grande que una sello de correo que puede liberar cerca de 2.3 voltios, energía suficiente para alimentar una pequeña linterna o bombilla y a parte, condensadores de alta capacidad. Es solo un prototipo por el momento pero se espera obtener nuevos avances para en un futuro poder disponer de fuentes de energía más pequeñas y ligeras.

Estan compuestas por un 90% de celulosa y una estructura de nanotubo de carbono. Según Robert Linhardt (uno de los responsables del proyecto): "Los componentes están molecularmente unidos entre sí. Se imprime el nanotubo de carbono sobre el papel, y el conjunto se empapa de electrolitos."

 Estas baterías de papel funcionan incluso si se doblan, enrollan o cortan, lo que permite modificar su formar y controlar su potencia y voltaje según el tamaño y, además tienen un funcionamiento en un amplio rango de temperaturas.

La batería usa papel con un electrolito y nanotubos de carbono que están encajados en el papel. Los nanotubos forman los electrodos, el papel es el separador y el electrolito permite el flujo de corriente. Se ha demostrado que la sangre y el sudor son electrolitos adecuados para su funcionamiento, lo que podría traducirse en una posible uso en aplicaciones biológicas y médicas.
 

Recien salida del horno, Google lanza una nueva funcionalidad llamada historial web que nos permite almacenar el historial de busquedas realizadas con la posibilidad de ampliar a las webs visitadas, para esto último hay que hacer uso de la barra de google y tener activada la funcionalidad pagerank. También permite, por suerte, darte de baja en cualquier momento. Ahí va una imagen (pincha en ella para agrandar):

Ya sabéis que desde hace unos días está disponible la beta 2 de Visual Studio 2008 (codename Orcas) junto con la beta 2 de Framework 3.5. Pues bien, como las versiones beta de cualquier producto pueden generar algún conflicto al intentar instalar una versión posterior del mismo he decidido probarlo sobre una máquina virtual. Para ello descargué el Virtual PC 2007 desde aquí. Por otro lado, si teneis a mano un CD de Kit de Bienvenida de Imagine Cup, sí aquel que te mandaban a casa cuando pasabas la fase 1 (test) de la Imagine Cup, ya teneis una máquina virtual en dicho disco (también incorpora Virtual PC 2004) que podreis utilizar directamente para programar, pues viene con VS 2005 y SQL Server 2005 sobre un XP. Así os ahorrareis un tiempo considerable en preparar una maquina virtual, si es que no disponeis de una, para poder hacer uso de ella. Por otro lado y puesto que los fondos de escritorio que vienen de serie con Windows XP son algo feos, os podéis descargar algunos de los fondos de escritorio que vienen con Vista desde la web del autor.

Intel libera la biblioteca TBB 2.0 (Thread Building Blocks) que permite generar una capa de abstracción sobre la arquitectura de threads de la plataforma usada, facilitando la programación multinúcleo. Esto es para aprovechar la capacidad que pueden darlos los procesadores de última generación con dos y cuatro nucleos a los que no se les saca todo el rendimiento posible. TBB es una librería en C++ que ahora esta disponible como un proyecto open source bajo licencia GPLv2 junto a la versión que da soporte comercial completo.

La librería soporta, entre otros, los micros Pentium 4, Pentium D, Xeon, Core Duo, Core 2 Duo y procesadores no Intel compatibles con los anteriores. Además esta disponible para sistemas operativos como Windows XP Professional, Server 2003, Vista, Red Had Enterprise, SuSE Enterprise Server, Mandrake 10, Mac OS X 10.4.4 y los compiladores de Visual Studio 2003, Visual Studio 2005, compiladores C++ Intel para Windows, Linux y Mac, y GCC. Para mayor detalle de los requisitos software y hardware pincha aquí.

He encontrado este buscador de código llamado Krugle y que parece bastante interesante la funcionalidad que nos puede aportar. Nos permite buscar contenido entre más de cuarenta lenguajes diferentes y en diferentes áreas como definición de clases y funciones, código fuente, comentarios, llamadas a funciones. A parte de esto, el resultado de una búsqueda lo podemos dividir en código, sites y proyectos, de este modo si encontramos cierto código que nos resulte útil para poder utilizarlo basta con guardarlo en un archivo y agregarlo a proyecto al que queramos o estemos trabajando y si queremos obtener mas información podemos ver al proyecto al que pertenece. También dispone de una serie de plug-ins con los que podemos realizar búsquedas en los navegadores IE y Firefox. Hay otro plug-ins más para el lado oscuro Eclipse con el que podemos realizar búsquedas directamente desde el entorno.

Uno de los grandes cambios de Windows XP a la versión de Windows Vista es el nuevo sistema gráfico que éste último incorpora, el cual ha sido denominado Aero. Se puede decir que Aero de divide en dos niveles, Aero Basic que ya incorpora una diferencia sustancial respecto a la interfaz gráfica de Windows XP y, Aero Glass (que no esta soportado por la versión “Home Basic”) proporciona una funcionalidad mayor como la aplicación de efectos de cristal a las ventanas o una gestión avanzada de las mismas, a parte de la experiencia visual que puede resultar más o menos gratificante dependiendo de los gustos particulares de cada uno.

Aero Glass hace que los bordes de nuestras ventanas hagan uso de transparencias para dar la sensación de cómo si estuviésemos viendo a través de un cristal, que tengamos vistas en miniatura de las aplicaciones que aparecen minimizadas en la barra de tareas o Windows Flip y Flip 3D. Esta funcionalidad queda expuesta a  través de DWM (Desktop Windows Management) que es quien se encarga de componer la apariencia que tiene el escritorio en cada momento.  Para poder ofrecer al usuario todo esto se hace uso directo de las aceleradoras gráficas, aquí es donde aparece el WDDM (Windows Display Diver Model), esta es la interfaz con la que DWM hace uso de los recursos de las tarjetas gráficas, así que si no disponemos de una gráfica más o menos reciente que soporte WDDM nos quedaremos sin "apreciar" todos estos efectos visuales. Se puede trabajar directamente con DWM pero es solo una posibilidad disponible para Vista, aun así, puesto que disponemos del Framework 3.0 en Windows XP y haciendo uso de WPF podemos simular este efecto de transparencia para los bordes de nuestras ventanas, aunque eso sí, no con la misma espectacularidad.

Vamos a trabar con Blend, así que creamos un nuevo proyecto de aplicación y listos para empezar con esto. Lo primero que tenemos que hacer es eliminar el típico marco de las aplicaciones de escritorio de XP. Para ello, en el objeto Window activamos la propiedad AllowsTransaprency, esto hará que automáticamente la propiedad WindowStyle cambie a None, a parte queremos darle a nuestra ventana el aspecto de borde redondeado con lo que tendremos que cambiar el valor de la propiedad Background a un color transparente así no aparecera un pico en las esquinas con el color de fondo de la ventana. El código quedaría en xaml del siguiente modo:

      AllowsTransparency="True"

      WindowStyle="None"

      Background="#00FFFFFF">

La ventana contiene un Grid en el que vamos a introducir un objeto de tipo Border que hará de marco de nuestra ventana y que pintaremos con un degradado. Para darle una apariencia más vistosa en realidad vamos a utilizar dos objetos border con un degradado diferente cada uno, de este modo el degradado no resultará tan "líneal", podemos usar los colores que más nos gusten y además tendremos que hacer uso de la componente alfa de los colores que formen parte del degradado para permitir ver lo que hay por detrás, es decir, darle transparencia al degradado. También modificaremos la propiedad CornerRadius para suavizar las esquinas:

  <Grid x:Name="LayoutRoot">

    <Border Margin="0,0,0,0" CornerRadius="5,5,5,5" ...>

      <Border.Background>

        <LinearGradientBrush>

            …

        </LinearGradientBrush>

      </Border.Background>

    </Border>

    <Border Margin="0,0,0,0" CornerRadius="5,5,5,5" ...>

      <Border.Background>

        <LinearGradientBrush>

            …<