Thomas Lebrun

[Windows Seven] How to use biometric authentication in your .NET applications ?

Thomas Lebrun — Wed, 19 Aug 2009 09:08:00 GMT

Currently, most of the laptops have a lot of features (SmartCard reader, etc.) that are not used.

But, with Windows Seven, one of this feature appears more useful: biometric authentication. Indeed, for the moment, this authentication must be done with tiers softwares, developed by constructors.

But now, Windows Seven get a new API allowing the programmation/manipulation of biometric readers. So it's now possible, by playing with some PInvoke, to create a wrapper for the API.

To help you, I've managed to create this wrapper. For now, only the method WinBioIdentifyWithCallback is implemented but it should be quite easy to implement other. This method allows to check, asynchronously, that the user who have swipe his finger on the sensor is effectively a know user:

In case of the user is unknow, the application receive an event which indicate the problem:

To use it, it's quite simple:

It's important to note that this wrapper is composed by 3 DLLs:

Biometric.Wrapper.dll: It's the managed DLL calling the unmanaged methods
Interop.WinBio.dll: This DLL contains the definition of the unmanaged methods (PInvoke). Instead of creating this DLL by hand, I've prefered to generate it by using the tool PInvoker. It's quick, workfs fine and, in case of any issue, tool's creator is really active so don't hesitate to give it a try !
PInvoker.Marshal.dll: DLL generated by the tool PInvoker and which contains the definition of thetypes that are used in Interop.WinBio.dll

To give a try to this, just follow this link : http://morpheus.developpez.com/blog/BiometricWrapper/BiometricWrapper.zip

Have fun !

Bye

[WPF / MVVM] How to get data in “design time” ?

Thomas Lebrun — Mon, 04 May 2009 02:00:00 GMT

When you are working with WPF and MVVM Pattern, you can regret that the designer doesn’t get data, in design time, that allow him to simply modified the graphical interface.

To help my developments, I’ve created a little attached property which will create an instance of the type passed in parameter:

public static class DesignTimeHelper
{
    /// <summary>
    /// DependencyProperty used to store the DesignTime property.
    /// </summary>
        public static readonly DependencyProperty DesignTimeDataProperty =
        DependencyProperty.RegisterAttached("DesignTimeData", typeof(Type), typeof(DesignTimeHelper), new FrameworkPropertyMetadata(null, new PropertyChangedCallback(OnDesignTimeDataChanged)));
 
    /// <summary>
    /// Gets the design time data.
    /// </summary>
    /// <param name="obj">The obj.</param>
    /// <returns></returns>
    public static Type GetDesignTimeData(DependencyObject obj)
    {
        return (Type)obj.GetValue(DesignTimeDataProperty);
    }
 
    /// <summary>
    /// Sets the design time data.
    /// </summary>
    /// <param name="obj">The obj.</param>
    /// <param name="value">The value.</param>
    public static void SetDesignTimeData(DependencyObject obj, Type value)
    {
        obj.SetValue(DesignTimeDataProperty, value);
    }
 
    /// <summary>
    /// Called when DesignTimeData changed.
    /// </summary>
    /// <param name="d">The source object.</param>
    /// <param name="e">The <see cref="System.Windows.DependencyPropertyChangedEventArgs"/> instance containing the event data.</param>
    private static void OnDesignTimeDataChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var isOnDesignMode = DesignerProperties.GetIsInDesignMode(new DependencyObject());
        if (isOnDesignMode)
        {
            var element = d as FrameworkElement;
            if (element == null)
                throw new NullReferenceException("element must not be null and must be an UIElement.");
 
            var designTimeDataType = e.NewValue as Type;
            if (designTimeDataType == null)
                throw new NullReferenceException("designTimeDataType must not be null.");
 
            element.DataContext = Activator.CreateInstance(designTimeDataType);
        }
    }
}

To use this attached property, it’s simple: just create 2 ViewModels (one used for the data in “runtime” and the second one used for the data in “designtime”):

Then, use the property:

At “design time”, we can see that data are really different from “runtime”:

For your information, here is the content of the ViewModel in “design” mode:

namespace TestToolbox.ViewModels.Design
{
    class SampleViewModel : ISampleViewModel
    {
        #region ISampleViewModel Members
 
        public string Text
        {
            get { return "Design time text"; }
        }
 
        public string Title
        {
            get { return "Design time title"; }
        }
 
        #endregion
    }
}

And here is the ViewModel for “runtime” mode:

namespace TestToolbox.ViewModels
{
    public class SampleViewModel : ISampleViewModel
    {
        #region ISampleViewModel Members
 
        public string Text
        {
            get { return "Runtime text"; }
        }
 
        public string Title
        {
            get { return "Runtime title"; }
        }
 
        #endregion
    }
}

That’s all ! Now, your designer is able to work with (sample) data that allow him to design the graphical interface of your application without having to launch it for testing/viewing the results.

Bye !

PS: Thanks to Simon for the suggestion of using a type instead of a simple string [;)]

[WPF] An addin to quickly generate your business objects compatible with WPF !

Thomas Lebrun — Tue, 07 Apr 2009 01:05:00 GMT

When I work on projects, I often need to create business objects (Customer, Country, etc.) and I would like to be able to done this step very quickly.

So I’ve created a little addin to Visual Studio 2008 that allow me to easily create my business objects/entities. This a an old project that I’ve decided to release even if I plan to re-write it because I think it could be an useful in addition to the XAML PowerToys developed by Karl Shifflett. To use it, just right click on a project and select “Add Business Object” under “VS PowerTools”:

Once this is done, a little window is displayed and you can specify the name of your entities, if you want to mark it as serializable (using the DataContract/DataMember attributes) and the number of properties:

Once you have entered the number of properties you want on your entities, just press the TAB key to see an interface that allow you to write the name and the type of the properties:

When you’re done, simply click the “OK” button to launch the create of the entity. Using CodeDOM, the addin performs the following tasks:

Add the references and “using” necessary
Create a partial class corresponding to the entity you have entered the name. This class implements INotifyPropertyChanged and INotifyPropertyChanging
Create the partial methods corresponding to the properties defined in your class
Define a collection for your class. The collection is simply a ObservableCollection of the type you’ve just created
Etc..

To install the addin, simply copy the file VSPowerTools.dll and VSPowerTools.AddIn to the Addins directory of Visual Studio 2008 (by default, it’s C:\Users\Username\Documents\Visual Studio 2008\Addins)

Here is a list of the thing that I’m planned to do for this addin:

Use M-V-VM pattern for the WPF part
Allow user to select if he want C# or VB.NET generated code
Manage the “Add Reference” part to support Silverlight (currently, the addin adds, as reference, the assemblies for the .NET Framework only, not Silverlight)
Maybe use a package instead of a simple addin

Here is the link to download the addin: http://morpheus.developpez.com/wpf/tools/addins/VSPowerTools1.0.zip

If you have any ideas or comments about this addin, feel free to contact me or to post a comment !

Happy coding !

[Silverlight 3] SaveFileDialog and the exception IOException: “The directory name is invalid”

Thomas Lebrun — Wed, 01 Apr 2009 10:09:00 GMT

I encountered a bug when I tried to use the control SaveFileDialog, available in Silverlight 3. Indeed, every time I used the method OpenFile, I received the following exception:

IOException: The directory name is invalid

At first, I tought it was an issue with the permissions on the location where I tried to save the file but, after posting a message on the Silverlight’s forums, it’s appears the issue come from the Protected Mode that was activated, in Internet Explorer, for the Local Intranet Zone:

"IE -> Tools -> Internet Options -> Security –> Enable/Disable Protected Mode"

As soon as I deactivate the protected mode, the call to the method OpenFile worked fine ! Of course, it’s a temporary fix because it’s not recommanded to keep the protected mode deactivated.

Happy coding !

Bye

[WPF] How to bind a control to a property defined in the Settings ?

Thomas Lebrun — Thu, 26 Mar 2009 08:23:00 GMT

Settings are a very powerful feature of .NET applications that allows developers to store some values in the settings of the application:

If you want to know how to bind a control to a property defined in the settings, it’s pretty simple. First, you need to add a custom XML namespace that will design the namespace where the settings are defined:

xmlns:properties="clr-namespace:TestSettings.Properties"

Then, in your XAML file, access the property using the following syntax:

x:Static properties:Settings.Default

So here is the final result code:

<ListBox x:Name="lb"
         ItemsSource="{Binding Source={x:Static properties:Settings.Default}, Path=Names}" />

That’s all :)

Happy coding !

Bye.

[WPF] How to develop and editable Textblock ?

Thomas Lebrun — Tue, 24 Mar 2009 07:16:00 GMT

Here is another request that a friend of mine asked me recently. To achieve this, I’ve just create a custom control that contains a TextBlock and a TextBox (which is hidden) controls.

When user double clic on the TextBlock, the Textbox appears.

So here is my proposition: in the file generic.xaml, put this:

<Style TargetType="{x:Type local:EditableTextBlock}">
    <Setter Property="Template">
        <Setter.Value>
            <ControlTemplate TargetType="{x:Type local:EditableTextBlock}">
                <Grid x:Name="PART_GridContainer" 
                      Background="{TemplateBinding Background}" 
                      Width="{TemplateBinding Width}" 
                      Height="{TemplateBinding Height}">
                    <TextBlock x:Name="PART_TbDisplayText"
                               Visibility="Visible"
                               Background="{Binding Mode=TwoWay, Path=TextBlockBackgroundColor, RelativeSource={RelativeSource AncestorType={x:Type local:EditableTextBlock}}}"
                               Foreground="{Binding Mode=TwoWay, Path=TextBlockForegroundColor, RelativeSource={RelativeSource AncestorType={x:Type local:EditableTextBlock}}}"
                               Text="{Binding Mode=TwoWay, Path=Text, RelativeSource={RelativeSource AncestorType={x:Type local:EditableTextBlock}}}" />
                    <TextBox x:Name="PART_TbEditText"
                             Visibility="Hidden"
                             Background="{Binding Mode=TwoWay, Path=TextBoxBackgroundColor, RelativeSource={RelativeSource AncestorType={x:Type local:EditableTextBlock}}}"
                             Foreground="{Binding Mode=TwoWay, Path=TextBoxForegroundColor, RelativeSource={RelativeSource AncestorType={x:Type local:EditableTextBlock}}}"
                             Text="{Binding Mode=TwoWay, Path=Text, RelativeSource={RelativeSource AncestorType={x:Type local:EditableTextBlock}}}" />
                </Grid>
            </ControlTemplate>
        </Setter.Value>
    </Setter>
</Style>

Then, here is the content that should go in the behind file:

[TemplatePart(Type = typeof(Grid), Name = EditableTextBlock.GRID_NAME)]
[TemplatePart(Type = typeof(TextBlock), Name = EditableTextBlock.TEXTBLOCK_DISPLAYTEXT_NAME)]
[TemplatePart(Type = typeof(TextBox), Name = EditableTextBlock.TEXTBOX_EDITTEXT_NAME)]
public class EditableTextBlock : Control
{
    #region Constants
    private const string GRID_NAME = "PART_GridContainer";
    private const string TEXTBLOCK_DISPLAYTEXT_NAME = "PART_TbDisplayText";
    private const string TEXTBOX_EDITTEXT_NAME = "PART_TbEditText";
    #endregion
    #region Member Fields
    private Grid m_GridContainer;
    private TextBlock m_TextBlockDisplayText;
    private TextBox m_TextBoxEditText;
    #endregion
    #region Dependency Properties
    public string Text
    {
        get { return (string)GetValue(TextProperty); }
        set { SetValue(TextProperty, value); }
    }
    public static readonly DependencyProperty TextProperty = DependencyProperty.Register("Text", typeof(string), typeof(EditableTextBlock), new UIPropertyMetadata(string.Empty));
    public Brush TextBlockForegroundColor
    {
        get { return (Brush)GetValue(TextBlockForegroundColorProperty); }
        set { SetValue(TextBlockForegroundColorProperty, value); }
    }
    public static readonly DependencyProperty TextBlockForegroundColorProperty = DependencyProperty.Register("TextBlockForegroundColor", typeof(Brush), typeof(EditableTextBlock), new UIPropertyMetadata(null));
    public Brush TextBlockBackgroundColor
    {
        get { return (Brush)GetValue(TextBlockBackgroundColorProperty); }
        set { SetValue(TextBlockBackgroundColorProperty, value); }
    }
    public static readonly DependencyProperty TextBlockBackgroundColorProperty = DependencyProperty.Register("TextBlockBackgroundColor", typeof(Brush), typeof(EditableTextBlock), new UIPropertyMetadata(null));
    public Brush TextBoxForegroundColor
    {
        get { return (Brush)GetValue(TextBoxForegroundColorProperty); }
        set { SetValue(TextBoxForegroundColorProperty, value); }
    }
    public static readonly DependencyProperty TextBoxForegroundColorProperty = DependencyProperty.Register("TextBoxForegroundColor", typeof(Brush), typeof(EditableTextBlock), new UIPropertyMetadata(null));
    public Brush TextBoxBackgroundColor
    {
        get { return (Brush)GetValue(TextBoxBackgroundColorProperty); }
        set { SetValue(TextBoxBackgroundColorProperty, value); }
    }
    public static readonly DependencyProperty TextBoxBackgroundColorProperty = DependencyProperty.Register("TextBoxBackgroundColor", typeof(Brush), typeof(EditableTextBlock), new UIPropertyMetadata(null));
    #endregion
    #region Constructor
    static EditableTextBlock()
    {
        DefaultStyleKeyProperty.OverrideMetadata(typeof(EditableTextBlock), new FrameworkPropertyMetadata(typeof(EditableTextBlock)));
    }
    #endregion
    #region Overrides Methods
    public override void OnApplyTemplate()
    {
        base.OnApplyTemplate();
        this.m_GridContainer = this.Template.FindName(GRID_NAME, this) as Grid;
        if(this.m_GridContainer != null)
        {
            this.m_TextBlockDisplayText = this.m_GridContainer.Children[0] as TextBlock;
            this.m_TextBoxEditText = this.m_GridContainer.Children[1] as TextBox;
            this.m_TextBoxEditText.LostFocus += this.OnTextBoxLostFocus;
        }
    }
    protected override void OnMouseDoubleClick(MouseButtonEventArgs e)
    {
        base.OnMouseDoubleClick(e);
        this.m_TextBlockDisplayText.Visibility = Visibility.Hidden;
        this.m_TextBoxEditText.Visibility = Visibility.Visible;
    }
    #endregion
    #region Event Handlers
    private void OnTextBoxLostFocus(object sender, RoutedEventArgs e)
    {
        this.m_TextBlockDisplayText.Visibility = Visibility.Visible;
        this.m_TextBoxEditText.Visibility = Visibility.Hidden;
    }
    #endregion
}

As you can see, it’s pretty simple but very useful :)

Happy coding !

Bye.

[Blend] XAML & Code Intellisense in Expression Blend 3

Thomas Lebrun — Mon, 23 Mar 2009 06:29:00 GMT

Version 3 of Expression Blend, which is available since last week, comes with a lot of new features. In this features, we can find Intellisense in XAML files:

So it’s just a real please for people who, like me, modify the XAML code: no need to open Visual Studio to have Intellisense !

But, we can also see another interesting point: the code editor (which was present in the very first Beta of Expression Blend and disappear then) now is again available, with Intellisense on C# or VB.NET files:

For sure, it’s not a good idea to develop an application using only Expression Blend (don’t fordet that you cannot have breakpoints…) but for doing some tests or prototypes, it’s really nice !

Happy (Silverlight & WPF) coding !

Bye.

[WPF] Another sample of WPF application using the pattern MVVM

Thomas Lebrun — Tue, 17 Mar 2009 09:29:00 GMT

To help new developers, here is a sample WPF application (that use the Northwind database) developed by using the pattern MVVM (Model View ViewModel).

The goal of this little application is just to give another example that will help to understand this new pattern that is really powerful !

I will try to make some blog posts about this pattern quickly. In the meantime, just enjoy this :)

The application can be downloaded here: http://morpheus.developpez.com/wpf/tools/DemoMVVM.zip

Bye.

[WPF] How to assign a dynamic resource from code-behind ?

Thomas Lebrun — Wed, 11 Mar 2009 10:46:00 GMT

When working on WPF projects, it’s mandatory to assign resources to user interface controls. When you work in XAML, it’s pretty simple: you just need to use the MarkupExtension named StaticResource (or DynamicResource if the resource is going to be modified):

<Button Content="Find Position" Click="Button_Click" Background="{DynamicResource brush}" />

But, how to do the same using code-behind ? The key is to use the method SetResourceReference (http://msdn.microsoft.com/en-us/library/system.windows.frameworkelement.setresourcereference.aspx):

<Window.Resources>
    <SolidColorBrush x:Key="brush" Color="Red" />
</Window.Resources>
 
<Button x:Name="btn"Content="Find Position" Click="Button_Click" /> 
 
this.btn.SetResourceReference(BackgroundProperty, "brush");

As you can see, it’s really simple to use: you define the resource, you define the control and, in code behind, you call the method SetResourceReference and use the following parameters:

the DependencyProperty on which the resource will be applied
the name of the resource

Happy coding !

[WPF] How to gray the icon of a MenuItem ?

Thomas Lebrun — Tue, 03 Mar 2009 09:40:00 GMT

Here is a question that a friend of mine asked me recently. Indeed, as a beginner with WPF, it thought that setting the property IsEnabled = false, on the MenuItem, will disable it. So, the following code:

<MenuItem Header="Edit">
    <MenuItem x:Name="miPaste"
              Header="Paste" IsEnabled="False" >
        <MenuItem.Icon>
            <Image Source="pack://application:,,,/Images/Paste.png"
/>
        </MenuItem.Icon>
    </MenuItem>
</MenuItem>

Does not deactivate the image, as you can see here:

To correct this, you have 2 choices:

Use a second gray image which will be specified as the source for the control if this one is deactivated
Use the class FormatConvertedBitmap to create a gray image

So I’ve created a little class, AutoGreyableImage, which allow you to have an image that will be turn in gray automatically when the control is desactivated.

Here is how you can use it:

<MenuItem Header="Edit">
    <MenuItem x:Name="miPaste"
              Header="Paste">
        <MenuItem.Icon>
            <local:AutoGreyableImage Source="pack://application:,,,/Images/Paste.png"
                                                   />
        </MenuItem.Icon>
    </MenuItem>
</MenuItem>

And here is the implementation:

/// <summary>
/// Class used to have an image that is able to be gray when the control is not enabled.
/// Author: Thomas LEBRUN (http://blogs.developpeur.org/tom)
/// </summary>
public class AutoGreyableImage : Image
{
    /// <summary>
    /// Initializes a new instance of the <see cref="AutoGreyableImage"/> class.
    /// </summary>
    static AutoGreyableImage()
    {
        // Override the metadata of the IsEnabled property.
        IsEnabledProperty.OverrideMetadata(typeof(AutoGreyableImage), new FrameworkPropertyMetadata(true, new PropertyChangedCallback(OnAutoGreyScaleImageIsEnabledPropertyChanged)));
    }
    /// <summary>
    /// Called when [auto grey scale image is enabled property changed].
    /// </summary>
    /// <param name="source">The source.</param>
    /// <param name="args">The <see cref="System.Windows.DependencyPropertyChangedEventArgs"/> instance containing the event data.</param>
    private static void OnAutoGreyScaleImageIsEnabledPropertyChanged(DependencyObject source, DependencyPropertyChangedEventArgs args)
    {
        var autoGreyScaleImg = source as AutoGreyableImage;
        var isEnable = Convert.ToBoolean(args.NewValue);
        if (autoGreyScaleImg != null)
        {
            if (!isEnable)
            {
                // Get the source bitmap
                var bitmapImage = new BitmapImage(new Uri(autoGreyScaleImg.Source.ToString()));
                // Convert it to Gray
                autoGreyScaleImg.Source = new FormatConvertedBitmap(bitmapImage, PixelFormats.Gray32Float, null, 0);
                // Create Opacity Mask for greyscale image as FormatConvertedBitmap does not keep transparency info
                autoGreyScaleImg.OpacityMask = new ImageBrush(bitmapImage);
            }
            else
            {
                // Set the Source property to the original value.
                autoGreyScaleImg.Source = ((FormatConvertedBitmap) autoGreyScaleImg.Source).Source;
                // Reset the Opcity Mask
                autoGreyScaleImg.OpacityMask = null;
            }
        }
    }
}

Here is the result:

You can download the sources (and the demo) here: http://morpheus.developpez.com/wpf/DisableMenuItemIcon.zip/wpf/DisableMenuItemIcon.zip

Happy coding !

[WPF] How to be notified when an internal DependencyProperty is modified ?

Thomas Lebrun — Fri, 27 Feb 2009 10:12:49 GMT

When you create your own Dependency Properties, you can define some callbacks that will be called when the value of the property is modified. But, how to do the same with an internal Dependency Property of WPF ?

Here is a sample:

public MyControl()
{
    DependencyPropertyDescriptor.FromProperty(WidthProperty, typeof(MyControl)).AddValueChanged(this,
        delegate
            {
                MessageBox.Show("Value has been modified!");
            });
}

As you can see, you need to call the FromProperty method of the DependencyPropertyDescriptor class, passing it the Dependency Property that you want to track, the type of your control and then, calling the AddValueChanged method with a delegate to the code that need to be called when the property is modified.

As you can see, it’s simple but very useful and it appears to be the only way to know when a row is selected on the XCeed datadrig…

Hope this helps !

Thanks.

Welcome to my English blog !

Thomas Lebrun — Thu, 26 Feb 2009 16:25:00 GMT

Hello everybody,

This is my first post on this blog so I’ll try to present myself to let you know who I’m !

My name is Thomas LEBRUN and I’m currently a consultant and trainer (MCT) at Winwise in Paris (France). I started to use .NET in 2002, in particular C# language. For my contributions to the french community, Microsoft has honored me with the title of Client Application Development MVP since 2007.

My main role is architect on Smart Client technologies: WPF, Silverlight, etc.. I speak at some conferences for Winwise or Microsoft (TechDays), mainly about Windows Presentation Foundation, Silverlight and VSTO (Office Development).

I’ve a french blog that’s located here: http://blogs.codes-sources.com/tom (fr). This blog mainly devotes itself to Windows Presentation Foundation & Silverlight. Also, I write articles for http://www.techheadbrothers.com (fr), http://ww.developpez.com (fr) and on a French magazine “Programmez”.

For my first posts on this blog, I will just translate the posts that are currently on my french blog and I hope they will be useful !

Thanks !

PS: As you will probably doubt, English is not my primary language so, in advance, forgive me for any mistakes I can do [:)]