Search results for 'app:weblogs' matching tag 'WPF'

Nederlandse CodeCamp 2009

Maurice — Mon, 19 Oct 2009 05:00:00 GMT

Op 21 november 2009 organiseren de SDN, Stichting dotNed en VBcentral samen het derde Nederlandse Code Camp. Dit is een dag lang met code, code sharing, freaking en gezellig samenzijn. Een evenement door ontwikkelaars, voor ontwikkelaars. De regie ligt voor een belangrijk deel bij de deelnemers! Het aantal plaatsen voor deelnemers is wel beperkt tot maximaal 150. Wacht dus niet te lang met beslissen want voor je het weet is er geen plaats meer. Vergeet bij je aanmelding niet op te geven welke onderwerpen je interesse hebben. Bovendien nodigen we iedereen graag uit om zelf een sessie in te vullen.

Op de website, www.codecamp.nl, vind je meer informatie en kan je je aanmelden.

New Features in CTP2 ADO.NET Data Services v1.5 Explained

NunoGodinho — Wed, 02 Sep 2009 05:00:00 GMT

After yesterdays post about the availability of the CTP2 of ADO.NET Data Services v1.5 here are some more details regarding the Projections, Feed Customization and Data Binding.

As told before Projections, the possibility of getting only the columns chosen instead of retrieving all the columns. With this we have now a new set of expressions to provide this ability on the URI, and in order to achieve we have now two new keywords available, that are:

$select, allow us to define which columns we want to be get
- Instead of using only the http://127.0.0.1/NorthwindService.svc/Customers that will return every column of the Entity Customer, we want to define that we only get the CustomerID and the ContactName, and in order to achieve this we use the new $select keyword like this http://127.0.0.1/NorthwindService.svc/Customers?$select=CustomerID,ContactName
- The way to define the several columns is to use commas to separate the column names.
- If we want to use this keyword and define all columns is the following http://127.0.0.1/NorthwindService.svc/Customers?$select=*

$expand, defines that along with the results from the requested entity, we also want to get the results from a specific relationship
- Usage: http://127.0.0.1/NorthwindService.svc/Customers?$expand=Orders/OrderDetails

But in order for this to work we need to add the following 2 properties to the service:

First, make projections available using the URI.

  1: config.DataServiceBehavior.AcceptProjectionRequests = true;

Secondly, make the protocol version to V2

  1: config.DataServiceBehavior.MaxProtocolVersion = System.Data.Services.Common.DataServiceProtocolVersion.V2;

For more information’s regarding this subject read this post from the Product Team.

Feed Customizations are the possibility to customize the way the feed is created instead of using only the default AtomPub version.

In order to achieve this customization we must use the EntityPropertyMappingAttribute that will define the relationship between the Property and the name that will be used in the feed.

In the following sample we are defining that when building the feed, instead of using the complete type definition

  1: <author>
  2:    <name>Nuno Godinho</name>
  3:    <email>someone@company.com</email>
  4: </author>

we will have the Author element with the value that is on the Name Property of the Author class (considering that Author is a type that contains several properties and one of them is Name):

  1: [EntityPropertyMapping(
  2:        "Author",/*Source property path , the property of the Entity type to be mapped*/
  3:        SyndicationItemProperty.AuthorName,/* Syndication item to which the Source Property is mapped*/
  4:        SyndicationTextContentKind.Plaintext,/* Syndication content kind for the syndication item this property is bound to */
  5:        true/* If  false the property value is only placed at the mapped location & removed from the <content> section of the atom:entry*/
  6:        )]

  1: <author>Nuno Godinho</author>

Introducing Web Friendly Feeds aka Friendly Feeds (Updated for CTP2)

ADO.NET Data Services Friendly Feeds , Mapping CLR Types

ADO.NET Data Services Friendly Feeds , Mapping EDM Types – I

Data Binding is now simplified, because using the DataServiceCollection class we can bind it directly to the Data Service.

For more information’s regarding this subject read this post from the Product Team.

TemplateBinding inside ControlTemplate.Triggers

NunoGodinho — Tue, 01 Sep 2009 05:00:00 GMT

One of the limitations of TemplateBinding Markup in WPF is the fact that we cannot use it inside the ControlTemplate.Triggers because it really doesn’t work, since as Mike Hillberg said here, “TemplateBinding is a lightweight, but less functional, version of a Binding with a RelativeSource of TemplatedParent. One of the things that a TemplateBinding can't do is work within the ControlTemplate.Triggers; TemplateBinding only works within the template content” .

So we have this:

MyControl.cs

  1: 	public class MyControl : Control
  2: 	{
  3: 
  4: 		public Boolean Selected
  5: 		{
  6: 			get { return (Boolean)GetValue(SelectedProperty); }
  7: 			set { SetValue(SelectedProperty, value); }
  8: 		}
  9: 
 10: 		// Using a DependencyProperty as the backing store for Selected.  This enables animation, styling, binding, etc...
 11: 		public static readonly DependencyProperty SelectedProperty =
 12: 			DependencyProperty.Register("Selected", typeof(Boolean), typeof(MyControl), new UIPropertyMetadata(false));
 13: 
 14: 
 15: 
 16: 		public Brush SelectedColor
 17: 		{
 18: 			get { return (Brush)GetValue(SelectedColorProperty); }
 19: 			set { SetValue(SelectedColorProperty, value); }
 20: 		}
 21: 
 22: 		// Using a DependencyProperty as the backing store for SelectedColor.  This enables animation, styling, binding, etc...
 23: 		public static readonly DependencyProperty SelectedColorProperty =
 24: 			DependencyProperty.Register("SelectedColor", typeof(Brush), typeof(MyControl), new UIPropertyMetadata(Brushes.Red));
 25: 
 26: 
 27: 		public MyControl()
 28: 		{			
 29: 		}
 30: 
 31: 		protected override void OnInitialized(EventArgs e)
 32: 		{
 33: 			base.OnInitialized(e);
 34: 
 35: 			this.MouseLeftButtonDown += new System.Windows.Input.MouseButtonEventHandler(MyControl_MouseLeftButtonDown);
 36: 		}
 37: 
 38: 		void MyControl_MouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
 39: 		{
 40: 			MessageBox.Show(this.SelectedColor.ToString());
 41: 			this.Selected = !this.Selected;
 42: 		}
 43: 	}
 44:

Window1.xaml

  1: <Window x:Class="WpfApplication13.Window1"
  2:     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  3:     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  4: 	xmlns:local="clr-namespace:WpfApplication13"
  5:     Title="Window1" Height="300" Width="300">
  6:     <Grid>
  7: 		<local:MyControl x:Name="ctrl1">
  8: 			<local:MyControl.Template>
  9: 				<ControlTemplate TargetType="{x:Type local:MyControl}">
 10: 					<Grid Background="Green" x:Name="source"/>
 11: 					<ControlTemplate.Triggers>
 12: 						<Trigger Property="Selected" Value="true">
 13: 							<Setter TargetName="source" Property="Background" Value="{TemplateBinding SelectedColor}"/>
 14: 						</Trigger>
 15: 						<Trigger Property="Selected" Value="false">
 16: 							<Setter TargetName="source" Property="Background" Value="Green"/>
 17: 						</Trigger>
 18: 					</ControlTemplate.Triggers>
 19: 				</ControlTemplate>
 20: 			</local:MyControl.Template>
 21: 		</local:MyControl>
 22: 	</Grid>
 23: </Window>
 24:

When we compile we get the following error, "Cannot convert the value in attribute 'Value' to object of type ''. Error at object 'System.Windows.Setter' in markup file 'WpfApplication13;component/window1.xaml' Line 13 Position 58."

So how can we solve this problem?

Since the problem here is that TemplateBinding is not supported inside the ControlTemplate.Triggers, we have to find another way to make the binding, and so we just change the line 13 to

  1: 							<Setter TargetName="source" Property="Background" Value="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=SelectedColor}"/>

And if we look at the TemplateBinding Markup page in MSDN, the usage of TemplateBinding is similar to the Binding Markup using TemplatedPart as the RelativeSource, like {Binding RelativeSource={RelativeSource TemplatedParent}, Path=DependencyPropertyToBind}

Hope this helps.

Conferencia – Silverlight como Plataforma de Desarrollo

JuanKRuiz — Sun, 30 Aug 2009 05:00:00 GMT

Puedes ver el artículo original en mi blog:
http://juank.black-byte.com/eventos-silverlight-plataforma-desarrollo/

Fecha: Miércoles 2 de Septiembrea las 18:30 (-5 GMT)

Lugar: Auditorio Fundación Universitaria CAFAM
AK 68 N° 90-88 CAFAM Floresta, Bogotá – Colombia
¡¡¡..ENTRADA LIBRE…!!!!

Silverlight es una tecnología relativamente nueva en el mundo de las Aplicaciones Enriquecidas para Internet, la cual nos permite extender la funcionalidad de nuestras aplicaciones Web a través de un componente ligero, multi-plataforma y multi-navegador. En esta sesión podrás conocer cuáles son las características de la última versión de Silverlight que la hacen una excelente opción para construir este tipo de aplicaciones. Ven y conoce qué es Silverlight y cómo lo puedes utilizar como plataforma de desarrollo para aplicativos Web modernos.

PDF da Palestra WPF para Desenvolvedores WindowsForms (TechEdBrasil 2009)

Cmattos — Thu, 27 Aug 2009 05:00:00 GMT

Pessoal, conforme prometido, aqui está o link para baixar o PDF da minha palestra WPF para Desenvolvedores WindowsForms apresentada durante o TechEdBrasil 2009. http://msmvps.com/cfs-file.ashx/__key/CommunityServer.Blogs.Components.WeblogFiles/cmattos/8422.DEV202_5F00_CarlosMattos.pdf. Estou concluindo um artigo aborando todas as demos apresentadas nesta palestra. Este artigo será disponibilizado aqui no meu Blog, no portal Linha de Código e no MSDN Brasil Online. Por favor, comentem, participem, enviem suas dúvidas por e-mail.

Interesting Diagram Generation Controls

NunoGodinho — Thu, 06 Aug 2009 05:00:00 GMT

Some time from now I was searching for controls that would made the generation of diagrams of several kinds, like for instance::

Network Diagram
Worlflow Diagram
Database Diagram
Hierarchy Diagram
…

Basically I was trying to find a control that would solve the problem of having to search for different controls depending on the type of diagrams I would need in my projects, an in this case the project was in Silverlight. After a lot of research and a lot of CodeProject and others that would just fit a specific problem, I came across one that solved exactly what I was needing, and I found it on MindFusion named DiagramLite.

The DiagramLite is a quite interesting control since it provides a way for us to make available any kind of diagram in Silverlight and with the possibility of editing that diagram, and this makes it possible to create a new Workflow designer for our solutions using Silverlight. (Of course I now that this was done without this control, but it seems to me that it would be a lot easier with it, but this is just from my experience).

You can find samples here.

Along with the Silverlight version I also found that they also have several other versions for WPF, WinForms, ASP.NET, .Net Compact Framework and even Java, and for this it seems that they are pretty experts into the Diagram controls, and it’s pretty interesting since their support is pretty quick as well as clear.

I hope this post comes handy for you, since when it was me I had to to do a lot of searching and testing for several possibilities.

Annexe : Intégration de Xna dans WPF

valentin — Mon, 20 Jul 2009 05:00:00 GMT

Retourner au sommaire des cours

Il existe de nombreuses méthodes pour afficher des scènes 3D à base de Xna dans un environnement WPF. Certaines souffrent de problèmes de lenteur (réalisées le plus souvent à base de WindowsFormHost), d’autres ne permettent qu’une interaction limitée avec les contrôles et l’interface WPF. Réaliser des affichages multiples comme on peut en avoir dans des logiciels comme Maya devient alors problématique :

Il existe pourtant un moyen, relativement simple d’arriver à ses fins. Ce moyen consiste tout simplement à donner une impression visuelle à l’utilisateur d’une intégration Xna parfaite dans un widget WPF alors qu’il n’en est rien. La clé de cet effet réside dans une parfaite manipulation des fenêtres.

Principe

Nous voulons pouvoir intégrer notre scène Xna dans une interface WPF de la même manière que nous intégrons un Canvas ou un quelconque widget à une interface. Or le meilleur moyen d’afficher une scène 3D en Xna est de l’incorporer dans une fenêtre. Impossible en effet d’obtenir le handle de tout contrôle en WPF comme on peut le faire en Winform. L’astuce consiste alors à réécrire une partie du framework Xna tournant autour de la classe Game. Le but étant de faire hériter une nouvelle classe Game d’un Panel (dans notre cas un Canvas) afin de pouvoir l’intégrer dans l’arborescence visuel WPF. La surface visuelle de ce panel sera ainsi la zone d’affichage de la scène Xna liée. Pourtant nous venons de dire qu’il n’était pas possible d’obtenir un handle d’un contrôle visuel qui n’hérite pas de Window. Comment y afficher de la 3D avec Xna donc ? Nous allons tout simplement afficher une fenêtre sans bordure exactement au dessus de ce panel. Cette fenêtre sera toujours au dessus lorsque l’application aura le focus et que le panel sera visible, et sera cachée dans le cas contraire. De même, lorsque le panel n’est pas visible, nous stopperons l’activité du jeu.

Chaque modification de la taille ou de la position du panel entrainera une modification équivalente chez la fenêtre sus-jacente.

Cette fenêtre se trouvant donc exactement au dessus du panel et ayant une taille identique l’illusion est parfaite.

Réalisation

La première étape consiste donc à réécrire une partie des classes de l’assembly Microsoft.Xna.Framework et Microsoft.Xna.Framework.Game. Ce afin de s’émanciper du fonctionnement de base de la classe Game trop fortement couplée à un fonctionnement sur fenêtre unique. Le projet Arcane.Xna.Presentation reprend donc une partie des classes de ces assemblies pour une utilisation avec WPF.

Rien de bien compliqué. Seules les classes Game et GameHost sont réellement intéressantes ici.

La classe Game comme précisé précédemment correspond à la zone d’affichage de nos scènes 3D dans les interfaces utilisateurs WPF. Elle hérite de Canvas. L’utilisation de Canvas répond à un besoin bien particulier que nous présenterons plus loin. La classe Game ne se différencie de la classe Game de l’assembly Microsoft.Xna.Framework.Game que par quelques membres. Tout d’abord elle possède un membre de type GameHost qui est en fait la fenêtre se positionnant juste au dessus. Elle possède de même un membre nommé _tichGenerator qui va permettre de mettre à jour l’affichage à intervalle réguliers.

Le constructeur initialise ses membres ainsi :

this._window = new GameHost(this);

this._window.Closed += new EventHandler(_window_Closed);

this._tickGenerator = new DispatcherTimer();

this._tickGenerator.Tick += new EventHandler(_tickGenerator_Tick);

Il commence par créer la fenêtre qui sera située au dessus de lui, et enregistre l’événement Closed afin de fermer la scène 3D. L’object de type DispatcherTimer est utilisé pour la boucle de jeu et permet donc d’appeler de manière régulière les méthodes Update et Draw. Sa vélocité dépend de la propriété IsFixedTimeStep.

Dernier élément important, l’enregistrement de l’événement IsVisibleChange :

this.IsVisibleChanged += new DependencyPropertyChangedEventHandler(GameCanvas_IsVisibleChanged);

L’activation du DispatcherTimer est en fonction de cette visibilité.

La classe GameHost est tout aussi simple. Elle créé une fenêtre sans bordure, invisible sur la barre des tâches et qui enregistre l’événement SizeChanged du panel Xna et LocationChanged de la fenêtre de plus haut niveau. Ces deux événements lui permettent de toujours être au dessus du panel Xna en effectuant un appel à la méthode UpdateBounds :

public void UpdateBounds()
{
    if (this.IsVisible)
    {
        GeneralTransform gt = this.game.TransformToVisual(this.TopLevelWindow);

        this.Width = this.game.ActualWidth;
        this.Height = this.game.ActualHeight;

        this.Left = this.TopLevelWindow.Left + gt.Transform(new Point(0, 0)).X;
        this.Top = this.TopLevelWindow.Top + gt.Transform(new Point(0, 0)).Y;
    }
}

Cette méthode détermine la position de la fenêtre courante en se basant sur la fenêtre de plus haut niveau (la fenêtre contenant le panel Xna de la classe Game). Elle lui affecte en outre, la même largeur et hauteur que le panel Xna.

Là encore la fenêtre s’enregistre sur l’événement IsVisibleChange de ce dernier afin de se rendre visible ou non.

Premier Exemple

Nous baserons nos exemple sur le framework AvalonDock (http://www.codeplex.com/AvalonDock), un moyen efficace de créer des interfaces dockable à la Visual Studio très facilement. Un moyen aussi pour nous de montrer la puissance et la simplicité de notre système dans des interfaces WPF très avancées.

Notre solution contient donc un projet nommé Demo qui correspond au projet d’exemple d’AvanlonDock légèrement modifié. Nous avons ajouté une classe héritant de Game qui va afficher un cube tournant sur lui-même.

Cette classe a tout simplement été extraite d’une application Xna pur pour être ajouté dans ce projet, et ce, sans aucune modification (ou presque) :

public class RotatingCubeGame : Arcane.Xna.Presentation.Game
{

    #region Fields

    Arcane.Xna.Presentation.GraphicsDeviceManager graphics;
    SpriteBatch spriteBatch;
    BasicEffect effect;
    VertexPositionColor[] vertices;
    Vector3 position = Vector3.Zero;
    Vector3 size = Vector3.One;
    VertexBuffer vertexBuffer;
    IndexBuffer indexBuffer;

    #endregion

    #region Constructors

    public RotatingCubeGame()
    {
        if (!(System.ComponentModel.DesignerProperties.GetIsInDesignMode(this)))
        {
            graphics = new Arcane.Xna.Presentation.GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }
    }

    #endregion

    /// <summary>
    /// Allows the game to perform any initialization it needs to before starting to run.
    /// This is where it can query for any required services and load any non-graphic
    /// related content. Calling base.Initialize will enumerate through any components
    /// and initialize them as well.
    /// </summary>
    protected override void Initialize()
    {
         base.Initialize();
       // TODO: Add your initialization logic here
        this.graphics.IsFullScreen = false;
        this.graphics.PreferredBackBufferWidth = 800;
        this.graphics.PreferredBackBufferHeight = 600;
        this.graphics.ApplyChanges();

        this.Window.Title = "";

        this.InitializeVertices();
        this.InitializeIndices();

    }

    private void InitializeVertices()
    {
        vertices = new VertexPositionColor[ 8 ];
        vertices[0].Position = new Vector3(-10f, -10f, 10f);
        vertices[0].Color = Color.Yellow;
        vertices[1].Position = new Vector3(-10f, 10f, 10f);
        vertices[1].Color = Color.Green;
        vertices[2].Position = new Vector3(10f, 10f, 10f);
        vertices[2].Color = Color.Blue;
        vertices[3].Position = new Vector3(10f, -10f, 10f);
        vertices[3].Color = Color.Black;
        vertices[4].Position = new Vector3(10f, 10f, -10f);
        vertices[4].Color = Color.Red;
        vertices[5].Position = new Vector3(10f, -10f, -10f);
        vertices[5].Color = Color.Violet;
        vertices[ 6 ].Position = new Vector3(-10f, -10f, -10f);
        vertices[ 6 ].Color = Color.Orange;
        vertices[7].Position = new Vector3(-10f, 10f, -10f);
        vertices[7].Color = Color.Gray;
        this.vertexBuffer = new VertexBuffer(this.graphics.GraphicsDevice, typeof(VertexPositionColor), 8, BufferUsage.WriteOnly);
        this.vertexBuffer.SetData(vertices);
    }

    private void InitializeIndices()
    {
        short[] indices = new short[36]{
            0,1,2, //face devant
            0,2,3,
            3,2,4, //face droite
            3,4,5,
            5,4,7, //face arrière
            5,7,6,
            6,7,1, //face gauche
            6,1,0,
            6,0,3, //face bas
            6,3,5,
            1,7,4, //face haut
            1,4,2};
        this.indexBuffer = new IndexBuffer(this.graphics.GraphicsDevice, typeof(short), 36, BufferUsage.WriteOnly);
        this.indexBuffer.SetData(indices);
    }

    /// <summary>
    /// LoadContent will be called once per game and is the place to load
    /// all of your content.
    /// </summary>
    protected override void LoadContent()
    {
        // Create a new SpriteBatch, which can be used to draw textures.
        spriteBatch = new SpriteBatch(GraphicsDevice);

        // TODO: use this.Content to load your game content here
        this.effect = new BasicEffect(graphics.GraphicsDevice, null);
        this.effect.View = (Matrix.CreateLookAt(new Vector3(20, 30, -50), Vector3.Zero, Vector3.Up));
        this.effect.Projection = (Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, this.GraphicsDevice.Viewport.AspectRatio, 0.1f, 100f));
        this.effect.VertexColorEnabled = true;
    }

   /// <summary>
    /// Allows the game to run logic such as updating the world,
    /// checking for collisions, gathering input and playing audio.
    /// </summary>
    /// <param name="gameTime">Provides a snapshot of timing values.</param>
    protected override void Update(GameTime gameTime)
    {
        if (Keyboard.GetState()[Keys.Up] == KeyState.Down)
            position += Vector3.Up;
        if (Keyboard.GetState()[Keys.Down] == KeyState.Down)
            position += Vector3.Down;
        if (Keyboard.GetState()[Keys.Left] == KeyState.Down)
            position += Vector3.Left;
        if (Keyboard.GetState()[Keys.Right] == KeyState.Down)
            position += Vector3.Right;
        if (Keyboard.GetState()[Keys.PageUp] == KeyState.Down)
            size += new Vector3(0.1f, 0.1f, 0.1f);
        if (Keyboard.GetState()[Keys.PageDown] == KeyState.Down)
            size -= new Vector3(0.1f, 0.1f, 0.1f);

      // Allows the default game to exit on Xbox 360 and Windows
        if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
           this.Exit();

        float fAngle = (float)gameTime.TotalGameTime.TotalSeconds;

        //la transformation en elle même
        Matrix world = Matrix.CreateRotationY(fAngle) * Matrix.CreateRotationX(fAngle)
                            * Matrix.CreateScale(size)
                            * Matrix.CreateTranslation(position);

        this.effect.World = (world);
        base.Update(gameTime);
    }


    /// <summary>
    /// This is called when the game should draw itself.
    /// </summary>
    /// <param name="gameTime">Provides a snapshot of timing values.</param>
    protected override void Draw(GameTime gameTime)
    {
        this.graphics.GraphicsDevice.Vertices[0].SetSource(this.vertexBuffer, 0, VertexPositionColor.SizeInBytes);
        this.graphics.GraphicsDevice.Indices = this.indexBuffer;
        this.graphics.GraphicsDevice.VertexDeclaration = new VertexDeclaration(this.graphics.GraphicsDevice, VertexPositionColor.VertexElements);
        graphics.GraphicsDevice.Clear(Color.CornflowerBlue);

        // TODO: Add your drawing code here
        this.effect.Begin();

        foreach (EffectPass pass in effect.CurrentTechnique.Passes)
        {
            pass.Begin();
            this.graphics.GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, 8, 0, 12);
            pass.End();
        }

        effect.End();

        base.Draw(gameTime);
    }
}

Rien de bien compliqué ici (le code est extrait de l’article 6). La première modification est de faire hériter la classe RotatingCubeGame de l’objet Game de notre assembly et non celle de l’assembly Microsoft.Xna.Framework.Game. La seconde modification consiste à entourer les initialisations réalisées dans le constructeur de :

System.ComponentModel.DesignerProperties.GetIsInDesignMode(this)

Afin de s’assurer que notre jeu ne sera pas en partie créé dans le designer de Visual Studio. Le reste est très simple. Nous avons juste remplacé le contenu de chaque DockablePane dans le code Xaml de Window1 par un :

<Demo:RotatingCubeGame></Demo:RotatingCubeGame>

Le resultat nous donne :

Bien évidemment notre système respecte les avantage d’AvalonDock en permettant un docking puissant et ce, sans perturber nos scène 3D:

Pas mal, mais on peut faire mieux.

Intégration de Widgets

Pourquoi ne pas tenter d’afficher des widgets (bouton, label, Grid, Canvas, …) dans notre scène 3D pour faire une intégration avec WPF de manière parfaite.

Nous pourrions être tentés d’ajouter ces éléments directement à la fenêtre GameHost. Mais à l’affichage nous aurions des problèmes de scintillement (deux types d’affichages différents vectoriel et 3D à réaliser sur une même zone clip n’est pas forcement bon…). Nous allons donc simplement rajouter une nouvelle fenêtre au dessus de la fenêtre existante, sans bordure elle aussi :

Son contenu sera directement relié au contenu du panel Xna (le Canvas). La classe GameHost contiendra désormais un nouveau membre nommé _frontWindow de type Window. Elle exposera en internal une propriété nommée WPFHost donnant accès au Content de cette window :

internal object WPFHost
{
    get
    {
        return this._frontWindow.Content;
    }
    set
    {
        this._frontWindow.Content = value;
    }
}

La classe Game exposera elle-aussi le Content de cette window à l’aide d’une propriété portant le même nom :

public object WPFHost
{
    get
    {
        if (!(System.ComponentModel.DesignerProperties.GetIsInDesignMode(this)))
            return this.Window.WPFHost;
        else
            return (base.Children[0] as ContentControl).Content;
    }
    set
    {
        if (!(System.ComponentModel.DesignerProperties.GetIsInDesignMode(this)))
            this.Window.WPFHost = value;
        else
            (base.Children[0] as ContentControl).Content = value;
    }
}

Cette propriété détermine si nous sommes en mode design (sous visual studio) ou en mode runtime. En mode design nous utilisons le fonctionnement classique du Canvas dont hérite notre classe Game, en mode runtime nous ciblons directement la window. Cela nous permet en mode design de pouvoir voir l’UI de notre contrôle et de pouvoir la modifier à la souris.

En outre nous marquons la classe Game de l’attribut :

[System.Windows.Markup.ContentProperty("WPFHost")]

Permettant de mettre du contenu direct en Xaml :

La page Window1.xaml a été modifiée pour rajouter du contenu à plusieurs RotatingCubeGame comme le montre l’image ci-dessus. Nous avons ajouté des shapes et paths purs pour reproduire le personnage orange et jaune symbolisant le Xna, des boutons et label liés par des événements et un FlowDocument avec scrolling.

Conclusion

L’assembly Arcane.Xna.Presentation présente un moyen simple d’intégrer de manière professionnel du Xna à ses applications WPF. Le seul vrai défaut qu’on peut lui trouver est la création de deux fenêtre par panel Xna. Il faut savoir que le nombre de fenêtre affichable sous Windows est malheureusement limité. Le résultat fonctionne tout de même parfaitement et peut être utilisé pour des applications professionnelles :

Vous pouvez télécharger le code ici.

A bientôt sur ce Blog !

Valentin Billotte

WPF Charting is already available in WPF Toolkit of June 2009

NunoGodinho — Mon, 06 Jul 2009 05:00:00 GMT

The long wait has finished as the WPF Charting was made available on the last WPF Toolkit release of June 2009 and now we can use all those great charts that were available for Silverlight, now also in WPF.

You can know more about this here.

Work with the taskbar of Windows 7 in WPF applications

Sergun — Sat, 13 Jun 2009 05:00:00 GMT

Recently I have published a series of articles that has been devoted to possibilities of Windows 7 for developers to work with the task panel. I have received a large quantity of responses for this time. Thanks you very much for it. That is interesting, questions were absolutely various subjects. However, the most part of questions was on a theme of use of similar functionality in WPF applications. Really, in the majority of examples I have lost sight WPF applications. I will try to compensate this defect here.

Really, use of these possibilities in WPF applications not strongly differs from their implementation in WinForms. As is known, for use of possibilities of the task panel of Windows 7 we used WindowsFormsExtensions static class in which to contain extension-methods for Form class (form representation in Windows Forms). Unfortunately, in.NET Interop Sample Library there is no have similar class for WPF applications. However it is completely not difficult to create it independently.

If to look at WindowsFormsExtensions class it becomes clear, that all calls are forwarded to Windows7Taskbar class which for form identification is used Handle of window. In a case with Windows Forms the form has property Handle which returns the necessary value. The first task is to receive handle of WPF window. Unfortunately, WPF windows do not have Handle property. However, it is possible to take advantage of WindowInteropHelper class and to receive this information. For this purpose I have made one more method which returns Handle of WPF-window.

private static IntPtr GetWindowHandle(Window window)

    return (new WindowInteropHelper(window)).Handle;

Further in all extension methods it is necessary to change parametre type (type to which it is applied extension method) from Form to Window. After that the majority of possibilities are already accessible to WPF-applications.

Other problem at work with the task panel of Windows 7 is that in some situations it is required to intercept Windows messages which come to a current window. In Windows Forms for these purposes it was possible to override WndProc method and in it to catch all necessary messages.

protected override void WndProc(ref Message m)

    if (m.Msg == Windows7Taskbar.TaskbarButtonCreatedMessage)

        // ...

    base.WndProc(ref m);

Unfortunately, for WPF windows of such method is not present. However, in WPF application it is possible to take advantage of HwndSource object and to add interception of Windows messages through it.

private void Window_Loaded(object sender, RoutedEventArgs e)

    HwndSource.FromHwnd(new WindowInteropHelper(this).Handle).AddHook(WndProc);

private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)

    if (msg == WM_DWMSENDICONICLIVEPREVIEWBITMAP)

        // ...

    return IntPtr.Zero;

In other the usage of possibilities of the task panel of Windows 7 in WPF applications is implemented similarly Windows Forms.

Sample applications:

MIX’09 – Reviewing – Future of Expression Blend

NunoGodinho — Mon, 08 Jun 2009 05:00:00 GMT

Douglas Olson – General Manager

Christian Schormann – Director, Program Manager

Expression Mission

Enable professional designers to create great UX with better productivity at lower costs.
Help integrate design and designers into the process of software creation

Expression Blend 3 Goals

Enable early-stage design & prototyping (SketchFlow)
- Created to address issues felt at the start of the software design process:
  - Top-down & bottom-ups design lets you experiments with ideas
  - SketchFlow Player lets you try your design at any time
  - Facilitate communication of design ideas
  - Easy to gather, evaluate and use stakeholders feedback
- Blend Elements
  - SketchFlow Application Flow
    - Important to think on pages like whiteboards to sketch, insert elements, and all what you normally do.
- Usage of SketchStyles that will allow us to maintain the Sketchy style of the Design proposal, that is very important.
- Export to Word
  - Dumps all the SketckFlow elements like Application Flow, Pages, Comments and so on.
Make visual design easier for designer
- Embrace the Design Ecosystem
  - Adobe Photoshop & Illustrator file format import with extensive support for layers
    - Preview of Photoshop in Windows Explorer even without PhotoShop installed
    - Possibility to choose what to do with each layer
    - Blend informs if the font is default or not and gives the possibility to choose other font or even the same font by specifying the path of the font
    - All content will be fully editable
    - Layer Groups are also maintained
    - By selecting an object we can make “Make into Control”
      - We choose the type of control we want to create
      - What’s done is:
        
        A style is created in order for the control to became what was defined when we selected the elements to generate the control.
        
        The control created will replace the selected element and gain the same properties that the original element had.
        
        The style is associates to the control
        
        Note: There’s now a problem when the controls have different parts, like the Slider, and this will generate all but we need to wire-up the style to the correct parts
  - Fast and Easy Control Skinning
  - Enhanced editing of visual States
  - Richer state transitions
- Focus On Your Art
  - Redefined artboard interaction
  - Better gradient editing
Design with Data (Data Generation / Sampling inside Blend)
- In the Data Tab we will have the possibility to define the DataSource structure that we want, and then just generate the data, and there are some templates like Phone Numbers, Strings, Dates, and so on.
- Make it easy to build a data-driven applications:
  - Sample Data:
    - Design applications without access to live data source
    - Create sample data on the fly
    - Populate with configurable random data
  - Drag and Drop Master-Detail creation
  - Better user experience for data binding
  - Design-time support for Silverlight 3 controls
- There’s a Master and a Details Mode in the Data Tab that will make it easier to perform the Master-Details view
  - in this version of Blend we need to wire-up the Master and Detail elements, and this will not be needed in the last version of Blend
Build interactivity without code (Behaviors)
- Introduction to Behaviors:
  - Production-quality interactivity applied with Drag & Drop ease
  - A design pattern for reusable interactivity
  - Example: MouseGestureBehavior
    - You can define the gesture that will be used and make changes to the elements based on that gesture
Enable Source Code Control (Integration with Source Safe and TFS by default) – This is available also inside Expression Web
- Design for Developers
  - Source Control
    - Visual Studio Team Foundation Server Support
    - New editor with Intellisense for code & XAML
Support for Silverlight 3

Note:

The same features are available for WPF and Silverlight in Blend 3.

It’s important to avoid having final or high-definition elements in the Sketch design because customers will start looking in the direction of the rendering instead of the functionality.