Nuno Filipe Godinho : WPF

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

NunoGodinho — Wed, 02 Sep 2009 19:21:57 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 19:03:36 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.

Interesting Diagram Generation Controls

NunoGodinho — Thu, 06 Aug 2009 17:14:45 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.

WPF Charting is already available in WPF Toolkit of June 2009

NunoGodinho — Mon, 06 Jul 2009 21:57:53 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.

MIX’09 – Reviewing – Future of Expression Blend

NunoGodinho — Mon, 08 Jun 2009 13:14:23 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.

First Code Parts of Prism 2.0

NunoGodinho — Fri, 26 Sep 2008 18:07:53 GMT

As I previously posted, Prism 2.0 is shaping up and some of the new Code Parts are already available on CodePlex. Of course this is only a small part but it brings good news like:

Multi-targeting quick starts, that explains the structure that a Prism 2.0 project will have in order to be Multi-target for WPF and Silverlight, and in this case is a real state solution.
Multi-targeting Visual Studio Templates, in order to be possible to create the Prism 2.0 projects.
Project Linker Tool, that provides a guidance on how to structure an application in a way that is possible to link it to other applications in order to make it Multi-targeted.

Read more about it in the Readme file that defines this first drop, and also David Hill’s blog post about this subject.

Silverlight Applications Offline

NunoGodinho — Mon, 01 Sep 2008 18:45:53 GMT

This has always been an issue when we talk about Silverlight and so much as been said about it, and so let’s look at the options.

First of all we need to think that Silverlight was not built to be a technology to deliver Occasionally Online applications, it was built to deliver RIA, and so it was made to use Online and not Offline. Is this a problem?

Secondly, Silverlight is a subset of Windows Presentation Foundation (WPF), and so my question is: Do we really need the Occasionally Online approach in Silverlight or do we need to be able to run everything we do in Silverlight in WPF also?

And so my thoughts about my own questions are:

There’s no problem with Silverlight not having been thought in terms of needing the Occasionally Online approach because this is the purpose of WPF, but it must be enhanced with something like the Occasionally Offline approach, because sometimes our Internet connections go down, for several different reasons, and we don’t want to lose all our work done in the Silverlight apps. And if we think that Silverlight 2.0 was built to bring the ability not only for the islands of richness, that was brought by the version 1.0, but also to provide a platform to build Line-Of-Business Applications this will take a lot more importance.

Still about Silverlight having the need to support the Occasionally Online approach I would say that this isn’t really a must have because this is really an Architectural choice to be made during the product planing, and so if we need a Occasionally Online approach we use WPF, and if we need an Online approach we’ll use Silverlight.

OK this is nice but there’s one important aspect that we are forgetting and that is that a product will evolve and suddenly it can turn to need an Occasionally Online approach and so, what will we do? Will we need to build the application again? Of course not, this is where the interaction between WPF and Silverlight needs to appear, because it’s needed that all the features and even controls that work in Silverlight work well in WPF, because this is how real subset frameworks work, and is this now true in Silvelight and WPF? The answer is not everything works, but it’s being worked on.

So a lot still needs to be done in this two awesome technologies that bring great User Experience for applications, but we need to think also that they are relatively new because WPF with the release of .NET 3.5 SP1 just had it’s Third Major Release, and Silvelight is only going for it’s Second. This being said a lot should be expected in both this areas.

In terms of what choices do we have today for making Silvelight a Desktop application / Occasionally Online Applications, they are the following:

Pack it with a lightweight Web Server like Cassini Web Server
Pack it with a custom build Windows Service that will serve the Http Requests needed by the Silverlight App. This seams to me a lot harder because to much as to be done.
Transform it to a WPF like Application. Use this Desklighter tool that will convert your Silverlight App into a Desktop App.

This is a very interesting topic and I would like to ear your thoughts about this subject, so feel free to comment.

Windows Presentation Foundation Major Release 3

NunoGodinho — Wed, 27 Aug 2008 21:08:25 GMT

With the release of the .NET Framework 3.5 SP1 the WPF suffered the third major release of it’s short history.

This major areas that were affected were:

Deployment

Now instead of needing the full framework installation it was made a lightweight version in order to run only this technology, and this is called the Client Profile. This lightweight version that consumes 25 MB includes the following:

CLR (bases of the .NET Framework)

Click Once (Used in the installation of the WPF applications)

Windows Forms (Runtime used to run the Windows Forms solutions that can be held also inside WPF applications using WindowsFormsHost class)

Windows Presentation Foundation (Runtime used to run the WPF solutions that can also be held inside Windows Forms Applications using the ElementHost class)

Windows Communication Foundation (Runtime used to run and consume WCF services that are normally used by Windows and WPF applications)

Graphics

     This versions includes powerful enhancements on the WPF graphics primarily on the 3D scope in controls like UIElement3D and Viewport2DVisual3D (that is responsible for making 2D object viewable in 3D).

     Also brings the HLSL shaders with the ShaderEffect class, that are entirely implemented on the GPU level, which makes it a lot faster, in case you have the Pixel Shader 2.0 support on your hardware).

    Another class that was also enhanced was the WritableBitmap class that now enables a very efficient image manipulation, by giving the ability to provide bitmap images mapped in the system memory that will give us the ability to change it on runtime and have the effects immediately on the screen.

Performance

Changes to the cold start on the application that are now improved in 45% depending on the application size.

Virtualization optimizations such as in TreeView, columns that can now be virtualized and that will enable a better and easier creation of DataGrid controls.

New Controls

     The much asked Datagrid control is now part of the WPF controls that are made available, but that will be released after the .net 3.5 SP1 release.

     The Office Ribbon control is also part of the new WPF controls and will also be released after the .net 3.5 SP1 release as the DataGrid Control.

      A Rich functionality WebBrowser Control, that in the previous versions worked via a Frame Element, and now will permit javacript and other funcionalities that exist on the normal browsers, and also will provide the ability for WPF applications to host Silverlight contents.

Other Enhancements

     Support for String formatting on the databinding of text without having to implement the IValueConverter interface.

     Extended support for the XBAP for the Firefox by providing the ClickOnce native support inside it.

     Improvements in the WPF Designer of the Visual Studio 2008 solving some problems that existed with the rendering of elements majorly when they were based on other custom controls.

     There’s a change that needs to be made on the Blend 2.5 Preview in order to solve some of this problems and that can be downloaded here.

Integration

Improved DirectX integration by having the D3DImage class that enabled the developer to overlay or blend the Direct3D contents with the WPF contents.

In conclusion, all great stuff for those who develop using this powerful Microsoft Technology called WPF that changed the main community site to the WindowsClient.net/WPF.

For more information’s check the following links:

Jaime Rodriguez blog post on WPF 3.5 SP1 features.
WPF perfomance blog post on What’s New for Performance in WPF in .Net 3.5 SP1.
Tim Sneath blog post on Introducing the Third Major Release of Windows Presentation Foundation.

Composite Application Guidance for WPF (Prism) now goes to Silverlight 2.0

NunoGodinho — Thu, 07 Aug 2008 00:34:02 GMT

As I said in a previous post Composite Application Guidance for WPF formerly known as "Prism" was made available and this was a great news because now the development of WPF solutions is easier and as a Guidance that will lead us all the way, helping us make the right choices whenever problems emerge. This is great but being Silverlight a subset of WPF, so wouldn't be great to have the same kind of guidance for Silverlight 2.0?

This is precisely what the team thought and then they started working on it and now we have some "spike's" (A ’spike’ is a small and quickly developed sample application in order to mitigate some risks) being released that will do exactly this, as is announced by Ezequiel Jadib on his blog. It's worth to check and I think it will be very interesting in the near future.

Business Solutions in WPF

NunoGodinho — Tue, 08 Jul 2008 23:04:34 GMT

Normally Business Solutions tend to have a "grey" design and don't always have the best User Experience, and in order to show that mission critical solutions can also be developed with a better UX, Brad Adams on his blog made a post about what he thought to be a solution with a good UX and even presented the a WebCast that talks about what and how it was developed. In this case it's a WPF applications, but a Silverlight versions is on it's way. See more here.

Composite Application Guidance for WPF

NunoGodinho — Tue, 08 Jul 2008 22:25:17 GMT

WPF is a very interesting technology since it provides the possibility to have a better User Experience on our Windows Applications, and by doing so it attracted many designers, enthusiasts as well as Developers, Architects and IT Managers, but what happens with new technologies is that sometimes they are misused by developers and became a problem. And so in order to help developers and architects attend to this type of problems the Patterns and Practices Team has been working on a project named "Composite Application Guidance for WPF", that will make the necessary "mind" adjustments and bring flexibility to the development of new applications in WPF.

This comes on a road that has been very useful on several other technologies like, Web Client Software Factory for ASP.NET, Composite UI Application Block and Smart Client Software Factory for Smart Clients, and even the Enterprise Library, and by doing this the developer has a kind of guideline making the process of developing solutions a little easier.

So check this out here .