Windows 7: Coalescing timers

Bajo este título tan raro se encuentra escondida una de las características más interesantes de Windows 7 para desarrollar aplicaciones energéticamente eficientes.

Conforme la potencia de cálculo de los procesadores aumenta, también aumenta su consumo energético, y por supuesto el software juega un papel importante en este consumo. Así que lo que veremos en este post es algunas de las características más interesantes de Windows 7 para hacer aplicaciones energéticamente eficientes.

Los procesadores actuales incluyen funcionalidad que les permite establecerse en un estado de Power Ilde, en el que el procesador entra en un estado de bajo consumo de energía hasta que es interrumpido por alguna razón. La velocidad de los procesadores actuales hace que la medida de su tiempo comparada con la nuestra sea completamente abismal, ya que para nosotros un simple segundo es más que la eternidad para un procesador. Así que teniendo en cuenta este escenario y el consumo de CPU de la mayoría de los programas y del kernel en sí, el escenario más común a optimizar por la mayoría de las aplicaciones es el Idle. Es decir tenemos que hacer aplicaciones que respeten al máximo el estado de bajo consumo energético del procesador haciendo así que el procesador no esté constantemente saliendo y entrando de ese modo de bajo consumo energético, esto es así porque las constantes interrupciones hacen que se consuma más energía en esos cambios de estado que la energía que se ahora por estar el procesador en el estado de bajo consumo energético.

Sabiendo esto como podemos, los desarrolladores, hacer aplicaciones que no “molesten” tanto al procesador. Pongo molesten al procesador porque no se trata de no hacer funcionalidad por ahorrar energía, más quisiéramos, sino de intentar aprovechar al máximo las características de consumo de energía de Windows 7. Aquí tenemos algunas opciones.

· Evitar el uso de poolling, usar eventos, es decir en vez de están constantemente consultando una API para saber si un valor se ha establecido o se ha cambiado usar un evento de Windows para que se nos notifique ese cambio.

· No hacer poolling para conocer el estado energético del sistema, usar RegisterPowerSettingNotification

HPOWERNOTIFY WINAPI RegisterPowerSettingNotification(  
  __in  HANDLE hRecipient, 
  __in  LPCGUID PowerSettingGuid, 
  __in  DWORD Flags
);

· En el caso de que no se pueda usar un evento nunca hacer polling más a menudo que un segundo.

Para el caso de que tengamos que hacer poolling constantemente Windows 7 incluye una API nueva para hacer temporizadores agrupados (coalescing timers). Veamos que son estos temporizadores agrupados.

clip_image004

clip_image006

En las dos gráficas podemos ver fechas de dos colores verdes y naranjas. Las fechas verdes que son constantes en el tiempo representan los eventos periódicos del temporizador del sistema, del kernel. Las flechas naranjas representan los eventos de temporizador personalizados, que se producen en el sistema, es decir temporizadores que los programadores programan. Lo que podemos ver entre estas dos graficas en que en la gráfica de abajo, que representa a Windows 7, podemos ver como los temporizadores naranjas se han alineado con los temporizadores verdes, es decir ahora los eventos se retrasan para agruparse cuando el sistema se levanta del estado de Ilde. Esto permite que entre evento y evento de color verder (kernel), el sistema se encuentre en completo idle y así que procesador pueda descansar durante ese periodo de tiempo, y solo cuando el procesador necesita ser “levantado” para ejecutar el evento del sistema (verde) aprovechamos y ejecutamos los eventos personalizados (naranjas) que tengamos pendientes.

Como podéis ver es una solución muy ingeniosa para optimizar nuestro escenario más habitual que como dijimos antes es el Idle del pc. Esto no significa que tengamos que cambiar todos nuestros temporizadores a temporizadores agrupados (coalescing timers), sino que si estamos haciendo alguna tarea en segundo plano, como monitorizar una web, o un dispositivo, podemos usar estos temporizadores para hacer nuestra aplicación más óptima con el consumo energético. En cualquier otro caso podemos seguir usando los temporizadores normales.

Este tipo de temporizadores es muy util para usarse en servicios de sistema que necesitan monitorizar algo en segundo plano.

Para crear un temporizador tenemos que llamar a la función CreateWaitableTimerEx

HANDLE WINAPI CreateWaitableTimerEx(  
    __in_opt  LPSECURITY_ATTRIBUTES lpTimerAttributes,  
    __in_opt  LPCTSTR lpTimerName,  
    __in      DWORD dwFlags, 
    __in      DWORD dwDesiredAccess
);

Una vez llamado tenemos que llamar a la función SetWaitableTimerEx para inicializar el temporizador.

BOOL SetWaitableTimerEx(  
    __in  HANDLE hTimer, 
    __in  const LARGE_INTEGER *lpDueTime, 
    __in  LONG lPeriod,  
    __in  PTIMERAPCROUTINE pfnCompletionRoutine, 
    __in  LPVOID lpArgToCompletionRoutine,  
    __in  PREASON_CONTEXT WakeContext,  
    __in  ULONG TolerableDelay
);

Quiero resaltar en esta función SetWaitableTimerEx, que el último parámetro ULONG TolerableDelay es el tiempo máximo en el que el temporizador puede ser retrasado para poder ser agrupado, así podemos indicar un tiempo por el cual el temporizador puede esperar sin problema, pasado este tiempo el sistema ejecutará el temporizador como un temporizador normal.

O podemos abrir un temporizador existente llamando a OpenWaitableTimer

HANDLE WINAPI OpenWaitableTimer(  
    __in  DWORD dwDesiredAccess,  
    __in  BOOL bInheritHandle,  
    __in  LPCTSTR lpTimerName
);

Para los programadores administrador (.NET) incluyo código de una clase que implementa esta funcionalidad:

public sealed class CoalescingTimer : IDisposable
    {
      private IntPtr _timer;
    
      public CoalescingTimer(string name)
      {
          _timer = UnsafeNativeMethods.CreateWaitableTimerEx(IntPtr.Zero, name, 0, TIMER_MODIFY_STATE);
      }
    
      public event EventHandler Tick;
    
      public void Set(Int64 dueTime, int period, string reason, uint tolerableDelay)
      {
          UnsafeNativeMethods.POWER_REQUEST_CONTEXT reasonContext = new UnsafeNativeMethods.POWER_REQUEST_CONTEXT();
          reasonContext.Version = UnsafeNativeMethods.POWER_REQUEST_CONTEXT_VERSION;
          reasonContext.Flags = UnsafeNativeMethods.POWER_REQUEST_CONTEXT_SIMPLE_STRING;
          reasonContext.SimpleReasonString = reason;
          _registeredDelegate = new CoalescingTimerProc(OnTimer);
          bool success = UnsafeNativeMethods.SetWaitableTimerEx(_timer, ref dueTime, period, _registeredDelegate, IntPtr.Zero, ref reasonContext, tolerableDelay);
      }
    
      private CoalescingTimerProc _registeredDelegate;
    
      private void OnTimer(IntPtr argument, uint timerLowValue, uint timerHighValue)
      {
          if (Tick != null)
              Tick(this, EventArgs.Empty);
      }
    
      const uint TIMER_MODIFY_STATE = 0x0002;
    
      public void Dispose()
      {
          UnsafeNativeMethods.CloseHandle(_timer);
      }
    }
    internal delegate void CoalescingTimerProc(
      IntPtr argument,
      uint timerLowValue,
      uint timerHighValue);
    
    internal sealed class UnsafeNativeMethods
    {
      [DllImport("kernel32.dll")]
      public static extern IntPtr CreateWaitableTimerEx(
          IntPtr lpSecurityAttributes,
          string timerName,
          uint flags,
          uint desiredAccess);
    
      [DllImport("kernel32.dll")]
      public static extern bool SetWaitableTimerEx(
          IntPtr hTimer,
          ref Int64 dueTime,
          int period,
          CoalescingTimerProc completionRoutine,
          IntPtr argument,
          ref UnsafeNativeMethods.POWER_REQUEST_CONTEXT reasonContext,
          uint tolerableDelay);
    
      [DllImport("kernel32.dll")]
      public static extern bool SetWaitableTimerEx(
          IntPtr hTimer,
          ref Int64 dueTime,
          int period,
          CoalescingTimerProc completionRoutine,
          IntPtr argument,
          ref UnsafeNativeMethods.POWER_REQUEST_CONTEXT_DETAILED reasonContext,
          uint tolerableDelay);
    
      [DllImport("kernel32.dll")]
      [return: MarshalAs(UnmanagedType.Bool)]
      public static extern bool CloseHandle(IntPtr handle);
      [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
      public struct POWER_REQUEST_CONTEXT
      {
          public UInt32 Version;
          public UInt32 Flags;
          [MarshalAs(UnmanagedType.LPWStr)]
          public string SimpleReasonString;
      }
  }

Luis.

Pixel Shaders in Siverlight 3.0 and WPF !!

Ahora que ha salido Siverlight 3.0 Beta 1, podemos ver que una de las caracteristicas que incluye es soporte para Pixel Shaders, pero realmente, ¿Qué son los Pixel Shaders?

image

Pixel Shader es unas de las partes de un Shader. Shader es un conjunto de instrucciones que la tarjeta gráfica ejecuta, estas instrucciones están muy optimizadas para el trabajo con colores, números de coma flotante y triangulos. Eso significa que los Shaders son como una especie de ensamblador que se ejecuta en la tarjeta gráfica, son muy parecidos a las extensiones multimedia de los procesadores, (MMX SSE).

Como podemos ver en esta grafica la imagen en 3D que se procesa en una tarjeta grafica pasa por diferentes pasos hasta que se muestra en la pantalla, cada uno de estas gráficas se pueden llamar técnicas, que están compuestas de un Verter Shader y de un Pixel Shader.

Verter Shader trabaja con la información de la malla (Mesh) de los objetos 3D que hay en la memoria de la tarjeta grafica a través de matrices.

Una vez que esta información se ha procesado se rellena el objeto con una textura, y ahora se puede procesar un Pixel Shader, que permite aplicar un efecto a cada uno de los pixeles finales de la imagen proyectada del objeto 3D, eso significa que los Pixel Shaders están pensados para imágenes 2D.

Pues bien en todo este conjunto de funcionalidades, en WPF y Silverlight 3.0 Beta1 tenemos soporte para Pixel Shaders.

¿Eso qué significa?, Pues bien, que podemos definir un algoritmo para una imagen 2D que se ejecutará en la tarjeta gráfica.

¿Qué tiene esto de bueno?, Una de las cosas buenas que tiene, es que evidentemente la tarjeta gráfica es mucho más potente en este tipo de cálculos que el procesador, porque está pensado para esto, así que significa que podemos tener efectos espectaculares que ejecutan en tiempo real en WPF y Silverlight 3.0 Beta 1.

Vale, me has convencido, como puedo empezar a escribir uno de estos estupendos shaders?

Vamos a ver como se integran los Pixel Shaders dentro de WPF y de Silverlight 3.0 Beta 1.

Voy a suponer que ya tenemos el Pixel Shader escrito, aquí tenemos uno de ejemplo:

sampler2D input : register(s0);
float factor : register(c0);

float4 main(float2 uv : TEXCOORD) : COLOR
{
    float4 color = 0;
    float angle = -3.14;
    float yDist = uv.y - 0.5;
    float xDist = uv.x - 0.5;
    float dist = sqrt(xDist * xDist + yDist * yDist);
    angle *= dist * factor;
    float xN = cos(angle) * xDist - sin(angle) * yDist;
    float yN = sin(angle) * xDist + cos(angle) * yDist;
    uv.x = xN + 0.5;
    uv.y = yN + 0.5;
    color = tex2D(input, uv);
    return(color);
}

La sintaxis es muy parecida a C, solo que ahora tenemos una función que acepta por parámetro un float2, que es un vector de dos posiciones de tipo float, que además está decorado con TEXCOORD, lo que indica que nos están pasando por parámetro la coordenada x,y del pixel entre 0 y 1, y si nos fijamos la función devuelve un float4, vector de 4 posiciones de tipo float, que está decorado con COLOR, lo que nos indica que tenemos que devolver el color del pixel de esa posición, como bien sabréis son 4 posiciones para RGBA (Red, Green, Blue, Alpha).

Las funciones que se utilizan dentro del cuerpo de la función soy muy sencillas e intuitivas para cualquier programador, así que no las vamos a comentar. La única que merece la pena es tex2D(sampler2D, float2) que acepta por parámetro un sampler, una imagen de origen, y una coordenada x,y y te devuelve el color del pixel en esa posición (float4), esta es la función que tenemos que llamar para saber cuál es el color del pixel del control o UIElement al que le estamos aplicando el efecto.

Como podéis observar esto está definido fuera del cuerpo de la función, en la que tenemos dos variables que son parámetros de entrada para el Pixel Shader, se definen el tipo, el nombre y luego el registro de entrada, en nuestro caso el registro s0 y c0, que dependiendo de la versión del Shader que soporte el hardware tendremos más registros o menos.

Pues bien para poder compilar este fichero tenemos dos opciones, hacerlo con el compilador de Shaders del SDK de DirectX usando este comando:

fxc /T ps_2_0 /E main /Fo<name of HLSL file>.ps <name of HLSL file>.fx

O podemos instalarnos un plug-in de msbuild para que desde Visual Studio compilemos el fichero .fx que contiene el Shader, para hacerlo tenemos que ir a esta web http://www.codeplex.com/wpf/ y descargar “Shader Effects BuildTask and Templates.zip”.

Una vez que tenemos el Pixel Shader compilado lo que tenemos que hacer es generar una clase que sea el ShadeEffect que podremos usar tanto en WPF como en Silverlight 3.0 Beta 1.

Aquí tenemos el ejemplo:

using System;
using System.Windows.Media.Effects;
using System.Windows;
using System.Windows.Media;
namespace MyVideoProject
{
    public class SwirlEffect : ShaderEffect
    {
        private static PixelShader _pixelShader = new PixelShader()
        {
            UriSource = new Uri("MyVideoProject;component/Swirl.ps",
            UriKind.Relative)
        };
        public SwirlEffect()
        {
            PixelShader = _pixelShader;
            UpdateShaderValue(InputProperty);
            UpdateShaderValue(FactorProperty);
        }
        public static readonly DependencyProperty InputProperty =
            ShaderEffect.RegisterPixelShaderSamplerProperty("Input", typeof(SwirlEffect), 0);
        public Brush Input
        {
            get { return (Brush)GetValue(InputProperty); }
            set { SetValue(InputProperty, value); }
        }
        public static readonly DependencyProperty FactorProperty =
            DependencyProperty.Register("Factor",
            typeof(double), typeof(SwirlEffect),
            new PropertyMetadata(0.0, PixelShaderConstantCallback(0)));
        public double Factor
        {
            get { return (double)GetValue(FactorProperty); }
            set { SetValue(FactorProperty, value); }
            }
        }
    }

Lo que estamos definiendo en esta clase es el fichero .ps, que contiene los bytes codes compilados del shader que se ejecutará en la tarjeta gráfica, y además dos Dependency Property especiales que serán los dos parámetros que definimos en el código fuente de nuestro Pixel Shader.

Por un lado se define FactorProperty de tipo double, (r0) y por el otro tenemos un registro del Dependency Property, solo que en vez de llamar a DependecyProperty.Register hemos llamado a ShaderEffect.RegisterPixelShaderSamplerProperty indicando el nombre de la DP y el índice del sampler (s0).

Una vez que se tiene definidos estas dos Dependency Property tenemos que indicar de alguna manera a la clase ShaderEffect que queremos que esos dos valores los actualice desde WPF/SL3.0 al Pixel Shader, eso es lo que se define en el constructor de la clase con las llamadas a UpdateShaderValue(InputProperty) y UpdateShaderValue(FactorProperty).

Así se cierra la definición de un Pixel Shader para su definición, si hubiéramos usado algún otro sampler o registro para nuestros Pixel Shader tendríamos que registrarlo para poder usarlo dentro del Pixel Shader.

Una vez definido todo esto ahora podemos usar nuestro Pixel Shader en WFP como en Silverlight 3.0 Beta 1.

Aquí tenemos un ejemplo de cómo usar nuestro Pixel Shader:

<Border
Margin="24">
    <Border.Effect>
        <local:SwirlEffect
        x:Name="mySwirlEffect"
        Factor="0" />
    </Border.Effect>
<Border>

Y este es el resultado:

clip_image004

Adjunto el proyecto de ejemplo que viene con Silverlight 3.0 Beta 1 Demos. Aquí.

Espero que os guste!!

Luis.

Silverlight 3 Beta 1 !!

Hoy gracias al Mix09 ha salido la primera beta de Silverlight 3.0, en los proximos días escribiré algún post sobre las caracteristicas concretas, ahora os dejo enlaces y caracteristicas.

Enlaces:

  • Silverlight 3 Beta Tools for Visual Studio – this will install the developer runtime of Silverlight 3 Beta, the Visual Studio project templates and the Silverlight 3 Beta SDK
  • Silverlight 3 Beta developer runtimes: Windows or Mac.  If you installed the tools above, you will get the developer runtime and there is no need to install it again.  These downloads are being made available for test machines for the Windows and Mac platforms for your applications.
  • Microsoft Expression Blend 3 Preview – this is the preview version of Expression Blend that will enable authoring of Silverlight 3 Beta applications.
  • Silverlight Toolkit – the toolkit has been updated to provide an updated to Silverlight 2 controls, a new release for Silverlight 3 Beta controls, and a new themes gallery.  All of these can be downloaded at the Silverlight Toolkit CodePlex project site.
  • .NET RIA Services – Microsoft .NET RIA Services simplifies the traditional n-tier application pattern by bringing together the ASP.NET and Silverlight platforms. The RIA Services provides a pattern to write application logic that runs on the mid-tier and controls access to data for queries, changes and custom operations. 
  • Silverlight 3 Beta Documentation – to view the Silverlight 3 Beta documentation you can view it online or download an offline CHM help file.

What’s New in Silverlight 3 Beta?

Fully supported by Visual Studio and Expression Blend, highlights of new features and functionality of Silverlight 3 include: major media enhancements, out of browser support allowing Web applications to work on the desktop; significant graphics improvements including 3D graphics support, GPU acceleration and H.264 video support; and many features to improve RIA development productivity. Also, in order to fully integrate all the .NET developer tools, Visual Studio 2008, Visual Studio 2010 and Visual Web Developer Express will support a fully editable and interactive designer for Silverlight. New features in Silverlight 3 include:

  • Support for Higher Quality Video & Audio. With support for native H.264/Advanced Audio Coding (AAC) Audio, live and on-demand IIS7 Smooth Streaming, full HD (720p+) playback, and an extensible decoder pipeline, Silverlight 3 brings rich, full-screen, stutter-free media experiences to the desktop. New and enhanced media features in Silverlight 3 include:
    • Live and on-demand true HD (720p+) Smooth Streaming. IIS Media Services (formerly IIS Media Pack), an integrated HTTP media delivery platform, features Smooth Streaming which dynamically detects and seamlessly switches, in real time, the video quality of a media file delivered to Silverlight based on local bandwidth and CPU conditions.
    • More format choice. In addition to native support for VC-1/WMA, Silverlight 3 now offers users native support for MPEG-4-based H.264/AAC Audio, enabling content distributors to deliver high-quality content to a wide variety of computers and devices.
    • True HD playback in full-screen. Leveraging graphics processor unit (GPU) hardware acceleration, Silverlight experiences can now be delivered in true full-screen HD (720p+).
    • Extensible media format support. With the new Raw AV pipeline, Silverlight can easily support a wide variety of third-party codecs. Audio and video can be decoded outside the runtime and rendered in Silverlight, extending format support beyond the native codecs.
    • Industry leading content protection. Silverlight DRM, Powered by PlayReady Content Protection enables protected in-browser experiences using AES encryption or Windows Media DRM.
  • Empowering Richer Experiences. Silverlight 3 contains new 3D graphics, animation features, hardware accelerated effects and text improvements that enable designers and developers to create next generation Web visuals. Additional features include:
    • Perspective 3D Graphics. Silverlight 3 allows developers and designers to apply content to a 3D plane. Users can rotate or scale live content in space without writing any additional code. Other effects include creating a queue in 3D and transitions.
    • Pixel Shader effects. These software based effects include blur and drop shadow. In addition, you can also write your own effect. Effects can be applied to any graphical content. An example would be to make a button appear depressed on rollover you could use a drop shadow effect on the pressed visual state.
    • Bitmap Caching. Silverlight 3 dramatically improves the rendering performance of applications by allowing users to cache vector content, text and controls into bitmaps. This feature is useful for background content and for content which needs to scale without making changes to its internal appearance.
    • New Bitmap API. With Silverlight 3, developers can now write pixels to a bitmap. Thus, they can build a photo editor to do red eye correction, perform edits on scanned documents or create specials effects for cached bitmaps from elements on the screen.
    • Themed application support. Developers can now theme applications by applying styles to their Silverlight 3 applications and changing them at runtime. Additionally, developers can cascade styles by basing them on each other.
    • Animation Effects. Silverlight 3 provides new effects such as spring and bounce. These make animation more natural. Developers can also now develop their own mathematical functions to describe an animation.
    • Enhanced control skinning. Silverlight 3 provides easier skinning capabilities by keeping a common set of controls external from an application. This allows the sharing of styles and control skins between different applications.
    • Improved text rendering & font support. Silverlight 3 allows far more efficient rendering and rapid animation of text. Applications also load faster by enabling the use of local fonts.
  • Improving Rich Internet Application Productivity. New features include:
    • 60+ controls with source code : Silverlight 3 is packed with over 60 high-quality, fully skinnable and customizable out-of-the-box controls such as charting and media, new layout containers such as dock and viewbox, and controls such as autocomplete, treeview and datagrid. The controls come with nine professional designed themes and the source code can be modified/recompiled or utilized as-is. Other additions include multiple selection in listbox controls, file save dialog making it easier to write files, and support for multiple page applications with navigation.
    • Deep Linking. Silverlight 3 includes support for deep linking, which enables bookmarking a page within a RIA.
    • Search Engine Optimization (SEO). Silverlight 3 enables users to solve the SEO-related challenges posed by RIAs. By utilizing business objects on the server, together with ASP.NET controls and site maps, users can automatically mirror database-driven RIA content into HTML that is easily indexed by the leading search engines.
    • Enhanced Data Support Silverlight 3 delivers:
      • Element to Element binding : UI designers use binding between two UI properties to create compelling UI experiences. Silverlight now enables property binding to CLR objects and other UI components via XAML, for instance binding a slider value to the volume control of a media player.
      • Data Forms. The Data Form control provides support for layout of fields, validation, updating and paging through data.
      • New features for data validation which automatically catch incorrect input and warn the user with built-in validation controls.
      • Support for business objects on both client and server with n-Tier data support. Easily load, sort, filter and page data with added support for working with data. Includes a new built-in CollectionView to perform a set of complex operations against server side data. A new set of .NET RIA services supports these features on the server.
    • Improved performance, through:
      • Application library caching, which reduces the size of applications by caching framework on the client in order to improve rendering performance.
      • Enhanced Deep Zoom, allows users to fluidly navigate through larger image collections by zooming.
      • Binary XML allows communication with the server to be compressed, greatly increasing the speed at which data can be exchanged.
      • Local Connection This feature allows communication between two Silverlight applications on the client-side without incurring a server roundtrip: for instance a chart in one control can communicate with a datagrid in another.
  • Advanced Accessibility Features. Silverlight 3 is the first browser plug-in to provide access to all system colors, allowing partially-sighted people to make changes such as high contrast color schemes for ease of readability by using familiar operating system controls.
  • Out of Browser Capabilities. The new out of browser experience in Silverlight 3 enables users to place their favorite Silverlight applications directly onto their PC and Mac, with links on the desktop and start menu—all without the need to download an additional runtime or browser plug-in. Further, the new experience enables Silverlight applications to work whether the computer is connected to the Internet or not—a radical improvement to the traditional Web experience. Features include:
    • Life outside the browser. Silverlight applications can now be installed to and run from the desktop as lightweight web companions. Thus, users can take their favorite Web applications with them, regardless of whether they are connected to the Internet or not.
    • Desktop shortcuts and start menu support. Silverlight applications can be stored on any PC or Mac computer’s desktop with links in the start menu and applications folder, and so are available with one-click access.
    • Safe and secure. Leveraging the security features of the .NET Framework, Silverlight applications run inside a secure sandbox with persistent isolated storage. These applications have most of the same security restrictions as traditional web apps and so can be trusted without security warnings or prompts, minimizing user interruptions.
    • Smooth installation. Because Silverlight applications are stored in a local cache and do not require extra privileges to run, the installation process is quick and efficient.
    • Auto-update. Upon launch, Silverlight applications can check for new versions on the server, and automatically update if one is found.
    • Internet connectivity detection. Silverlight applications can now detect whether they have Internet connectivity and can react intelligently including caching a users’ data until their connection is restored.

New Features in Expression Blend 3 Preview: The designer-developer workflow took another major step forward today with major innovations in Expression Blend 3 including: SketchFlow, a rapid prototyping capability that makes it easy to communicate design intent to stakeholders; design time sample data that enables the design and testing of applications without access to live data; direct import of Adobe Photoshop and Illustrator files; behaviors, extensible and reusable components that add interactivity to applications without writing code; a full code editor supporting C#, VB and XAML; and many more features that support an improved design and development experience.

  • SketchFlow. SketchFlow introduces a new set of features designed to make it easier for you to experiment with dynamic user experiences and create compelling prototypes. SketchFlow also helps communicate design ideas to other stakeholders, and makes it easier to collect in-context annotated feedback. SketchFlow enables the navigation and composition of an application to be modeled in a very visual manner from a simple prototype that uses a series of sketches, to something much more evolved. A prototype can be made as real and interactive as it needs to be to communicate design intent and SketchFlow can leverage all the existing features of Expression Blend.
  • Adobe Photoshop and Illustrator import. The powerful importers for both Adobe Photoshop and Adobe Illustrator enable smooth integration with workflows the designer already has in place. The designer has freedom to view and import Photoshop files layer by layer. Layers can be easily regrouped and elements retain their original formats; layers, layer positions, editable text and vectors remain available for editing within Expression Blend.
  • Behaviors. Add interactivity to your application, without having to write code. Behaviors can encapsulate complex design interactions into reusable components which can be directly applied to a user interface element in the application. Developers have access to a rich API that they can use to write their own triggers, actions, and behaviors for use in their Silverlight and WPF projects.
  • Sample data. Design time sample data makes it easy to build data-connected applications without access to live data. You can generate sample data or import sample data from an XML file and is available to controls on the artboard at design-time. You can extensively customize your sample data details, and you can easily switch between using sample data and using live data at run-time.
  • Improved design and development experience. Expression Blend 3 includes many features that improve the overall design experience including a brand new design surface making Blend more accessible to visual designers. Team Foundation Server support allows easier integration of the Blend user into Team System. Improved animation and easing functions, 3D transforms, visual effects and an improved visual state manager enable a great tooling experience.

Espero que os guste.

 

Luis.

Hola Mundo Surface con WPF

Como comente en mi anterior post el SDK del Surface incluye dos plantillas del proyecto para desarrollar en Surface, WPF y XNA. Pues bien vamos a ver como se hace una aplicación para Surface con WPF.

clip_image002

Si creamos el proyecto de Surface esto es lo que tenemos en la ventana de solución de proyecto.

clip_image004

Al ser una aplicación de WPF tenemos el clásico App.xaml que el objeto Application y la ventana principal. La ventana SurfaceWindow1.xaml se le ha cambiado la clase base y ahora en vez de ser Window es SurfaceWindow. También se ha cambiado en el xaml la clase base de esta manera.

<s:SurfaceWindow x:Class="SurfaceApplication1.SurfaceWindow1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:s="http://schemas.microsoft.com/surface/2008"
    Title="SurfaceApplication1"
    >
  <s:SurfaceWindow.Resources>
    <ImageBrush x:Key="WindowBackground" Stretch="None" Opacity="0.6" ImageSource="pack://application:,,,/Resources/WindowBackground.jpg"/>
  </s:SurfaceWindow.Resources>

  <Grid Background="{StaticResource WindowBackground}" >

  </Grid>
</s:SurfaceWindow>

De esta manera el Shell de Surface sabe que aplicaciones son aplicaciones de Surface.

A partir de este momento tenemos un proyecto de WPF normal y podemos empezar a programar de manera normal.

Como ya dije en mi post anterior, una de las características más atractivas de hacer aplicaciones para Surface en WFP es, además del hecho de que tenemos una serie de características propias de WPF (controles, layout, hardware accelerated), que también tenemos una serie de controles que Microsoft ha hecho que se pueden utilizar dentro de WPF.

Estos controles a los que me refiero son los common controls de WPF pero que ahora se han “surfeizado”, es decir si antes teníamos Button ahora tenemos SurfaceButton que permite tener un botón que es sensible a los contactos del dedo.

clip_image006clip_image008

Estos contactos (Contacts) son uno de los conceptos usados por Surface para reconocer que hay algo encima de la mesa. Estos contactos son parecidos a los eventos de raton, y podemos tener tres tipos de contactos, Finger, Blog, Tagged-object, que permiten reconocer si se ha puesto un dedo encima, un objeto mayor, o un objeto con un Tag.

Así que siguiendo con la filosofía de eventos propios del ratón ahora para los contactos tenemos eventos como estos: ContactEnter, ContactLeave, ContactChanged y demás.

Los controles mencionados anteriormente, son controles que ya tienen la funcionalidad propiea de los controles de Windows pero que responden a los eventos de contactos de Surface así que nosotros no tenemos que, en cada proyecto, implementar esa funcionalidad sino que podemos usar los que ya vienen, además de que todos los controles tiene soporte de tiempo de diseño, lo que significa que se visualizan correctamente en Expression Blend.

Podemos ver una captura aquí.

clip_image010

Así que ya podemos empezar a usar los controles de Surface para desarrollar nuestras aplicaciones de Surface. Además todos los controles están muy bien diseñados, es decir, que todos tienen un árbol visual bien definido, lo que permite que los diseñadores cambien el aspecto visual del control si que eso afecte al comportamiento del control.

Saludos desde Londres. Luis.

Microsoft Surface, SDK y WPF

Como todos sabréis esta semana se ha presentado el Microsoft Surface en Microsoft España. No se pueden decir más cosas sobre el proyMicrosoftSurfaceecto que vosotros sepáis, pero de lo que podemos hablar es del desarrollo de aplicaciones para Surface.

El Surface como cualquier otro gadget, el desarrollo de aplicaciones es una de las partes más importantes del dispositivo, pues las aplicaciones hacen que el Surface brille. Pues bien esta semana el día 2 de Marzo hice una presentación en Microsoft España sobre el desarrollo de aplicaciones para WPF y quiero compartir con vosotros esa experiencia.

¿Cómo se desarrollan aplicaciones para el Surface?, pues bien hay dos tipos de tecnología por el cual nosotros podemos desarrolla aplicaciones para el Surface que vienen incluidos en el SDK.

  • WPF (Windows Presentation Foundation)
  • XNA

XNA está más centrada en el desarrollo de videojuegos para Xbox360, Windows y Zune. Es una tecnología basada en .NET, lo que significa que podemos desarrollar nuestros videojuegos con C# y VB.NET.

Sobre WPF que decir… además de que es la caña, que nos permite que tanto diseñador como programador interaccionen y crear aplicaciones muy impactantes.

Ahora bien ¿que tecnología usar?, depende del tipo de aplicación. Con WPF vamos a tener muchas más cosas listas para poder trabajar con Surface, que con XNA, aunque WPF no tiene (por ahora) un soporte para 3D tan bueno como XNA. Eso significa que si queremos hacer una aplicación con un uso intensivo de 3D deberemos de usar XNA sin pensarlo. De todos modos en WPF tenemos soporte para 3D y tenemos todo lo bueno de WPF, layout, controles, tiempo de diseño, acelerado por hardware, ect.

Así que la decisión en principio puede ser fácil, nosotros en Plain Concepts hemos cosas en las dos tecnologías, pero usamos más WPF que XNA.

Feliz desarrollo de Surface.