Rudi Grobler

Me, Myself and I

I have to start off by apologising for the slow flow of blog articles the last 3 months but I promise you I had some good reasons… Things have been very hectic!

So, what happened the last 3 months?

On the 1st of April I received the awesome news that I have been selected as Microsoft MVP for Client Application Development!

“Congratulations! We are pleased to present you with the 2009 Microsoft MVP Award! This award is given to exceptional technical community leaders who actively share their high quality, real worl expertise with others.”

I have to thank 3 people without whom this would not have been possible! Ahmed & Eben (From Microsoft) for all their help getting me involved in the community!

Unfortunately putting in extra effort and getting involved in the community also takes it toll on you personal life… I have to thank my loving wife for putting up with me the last 2 years… Dankie my skat!

Tech-ed Africa 2009

I also received the excellent news that I would be presenting 3.5 sessions at this years Tech-ed Africa 2009

  • DTL314 - Creating “real” devices
  • WUX205 - Microsoft Expression Blend from a Developer's Point of View - Part 1
  • WUX201 - Microsoft Expression Blend from a Developer's Point of View - Part 2

Is that it?

Just too prove that I haven’t been sitting doing nothing… here is 2 articles I recently released

Classic JukeBox (Coding4Fun)

This article also featured on “This Week on Channel 9

PhotoBooth (CodeProject)

Behaviors, Triggers and Actions snippets

I am fortunate to be presenting a session about Expression Blend at Tech-ed Africa 2009  this year. One of the topics I will be covering is how easy it is to create behaviours, triggers and actions using Microsoft.Expression.Interactivity.dll!

Behaviours, triggers and actions is well encapsulated but still require a small amount of repetitive code… I created 3 snippets to aid in creating them! Here is the default implementations created using the snippets:

Behavior

/// <summary>
/// 
/// </summary>
public class MyBehavior : Behavior<FrameworkElement>
{
    /// <summary>
    /// 
    /// </summary>
    protected override void OnAttached()
    {
        base.OnAttached();
    }

    /// <summary>
    /// 
    /// </summary>
    protected override void OnDetaching()
    {
        base.OnDetaching();
    }
}

Trigger

/// <summary>
/// 
/// </summary>
public class MyTrigger : TriggerBase<FrameworkElement>
{
    /// <summary>
    /// 
    /// </summary>
    protected override void OnAttached()
    {
        base.OnAttached();
    }

    /// <summary>
    /// 
    /// </summary>
    protected override void OnDetaching()
    {
        base.OnDetaching();
    }
}

Action

/// <summary>
/// 
/// </summary>
public class MyAction : TriggerAction<FrameworkElement>
{
    /// <summary>
    /// 
    /// </summary>
    protected override void OnAttached()
    {
        base.OnAttached();
    }

    /// <summary>
    /// 
    /// </summary>
    protected override void OnDetaching()
    {
        base.OnDetaching();
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="parameter"></param>
    protected override void Invoke(object parameter)
    {

    }
}

Download the snippets here

More Information

If you found this interesting or useful please kick it on DotNetKicks.com

Posted by rudi | 3 comment(s)

Launching views using Jump Lists

Windows 7 has so many cool new features… One of the features that has great potential is the Jump Lists! This article shows how to launch different views for the same application using the Jump List feature of Windows 7

The basics

We will be using the default WPF MVVM application created using the MVVM Toolkit. There is only 2 changes I made before we can start:

  • I added a new View/ViewMode called CoolView/CoolViewModel (This is exactly the same code as the MainView/MainViewModel generated). To differentiate the two views, I changed their titles and background colors!
  • We also need to change the Application.OnStartup code that was generated to launch different views based on the args passed into the application. If the application is started with InCoolMode as a argument, then the CoolView/CoolViewModel gets loaded else we load MainView/MainViewModel. Here is the code
private void OnStartup(object sender, StartupEventArgs e)
{
    if (e.Args.Contains("InCoolMode"))
    {
        Views.CoolView view = new Views.CoolView();
        view.DataContext = new ViewModels.CoolViewModel();
        view.Show();
    }
    else
    {
        Views.MainView view = new Views.MainView();
        view.DataContext = new ViewModels.MainViewModel();
        view.Show();
    }
}

Now for the “good” stuff

It's a handy way to quickly reach the files you've been working with. To see the files you've used recently, just right click on the icon on your taskbar. So right-clicking on the Word icon will show your most recent Word documents. Plus, if there are other files you want to keep handy, you can just pin them to the Jump List so they’ll always appear. That way, the documents you’re likely to want are just a couple clicks away.

Some programs, such as Windows Media Player, can pre-populate their Jump Lists with common tasks. For example, on the Jump List for Windows Media Player, you’ll see options to Play All Music or resume your last playlist. On the Jump List for Internet Explorer, you’ll see frequently and recently viewed websites. With some programs, you’ll even have quick access to tasks that, in the past, were only available from within the program, such as composing a new e-mail message.

Windows 7 Jump Lists

We will be populating the Jump List with a task to launch the application in “Cool” mode!

Before we can start, we need to download the Windows® API Code Pack for Microsoft® .NET Framework (v0.85).

The Windows® API Code Pack for Microsoft® .NET Framework provides a source code library that can be used to access new Windows 7 features (and some related Windows Vista features) from managed code. These features are not available to developers today in the .NET Framework.

Reference Microsoft.WindowsAPICodePack.dll and Microsoft.WindowsAPICodePack.Shell.dll

Add the following code in Application.Startup

Taskbar.AppID = "MyCoolApp";
JumpList jumpList = Taskbar.JumpList;

string executablePath = Assembly.GetEntryAssembly().Location;
string executableFolder = Path.GetDirectoryName(executablePath);

// Add our user tasks
jumpList.UserTasks.Add(new JumpListLink
{
    Title = "CoOl MoDe",
    Path = Path.Combine(executableFolder, "JumpListDemo.exe"),
    Arguments = "InCoolMode",
    IconReference = new IconReference(Path.Combine(executableFolder, "JumpListDemo.exe"), 0)
});

jumpList.RefreshTaskbarList();

This will add a new Task “CoOl MoDe”. Here is how the Jump List looks

And that’s it! Now our super cool mode can be launched using the Jump List…

If you found this article cool or useful, please kick it on DotNetKicks.com

Posted by rudi | 3 comment(s)
Filed under: , ,

VS2010 help for the WPFer

As previously mentioned, I am busy kicking the tires of Visual Studio 2010… Their are LOADS of new things to talk about but I do quickly want to highlight 4 of my favourite enhancements for WPF developer…

Markup Extension Intelli-sense

In the dark days of VS2008, we had no intelli-sense help writing markup extensions… Luckily those days are gone!

WPF Tree Visualizer

Mole build into VS2010… What else do you expect since Molenator joined Microsoft?

Property Grid

Have a look at the following snippet of XAML

<Grid ShowGridLines="True">
    <!-- Content -->
</Grid>

This is how the property grid “shows” you which properties are set (even if thy are set to their defaults)

TIP: The context menu also makes it super easy to reset the property to its default value

Extract value to resource

The property grid context menu also allow you to extract a given property to a resource. Does this sound “familiar”? Another Molenator project? 

And this is only the tip of the ice berg…

Other enhancements

Adding WPF Controls to the Visual Studio 2010 Start Page

Drag-Drop Data Binding Comes to WPF in Visual Studio 2010

kick it on DotNetKicks.com
Posted by rudi | 4 comment(s)
Filed under: ,

Using the MVVM Toolkit in VS2010

In the past I have written about how much I like the MVVM Toolkit released by Microsoft! I recently decided to install VS2010 and kick the tires! Because most of my work is in WPF and I almost always use the MVVM pattern, I naturally needed to port the VS2008 project template to VS2010! Here is what you need to know

The MVVM toolkit installed the project template into the following directory

C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\ProjectTemplates\CSharp\Windows\1033

Copy the WpfModelViewApplicationProjectTemplateV0.1.cs.zip to a temporary directory and extract the content. Locate and open the WpfModelViewApplicationProjectTemplate.cs.vstemplate. Comment or remove the following lines

<WizardExtension>
  <Assembly>Microsoft.VisualStudio.Presentation.Extensions, Version=9.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35</Assembly>
  <FullClassName>Microsoft.VisualStudio.Presentation.Extensions.ModelView.TemplateWizard</FullClassName>
</WizardExtension>

Save the file and re-zip the directory content. All that is now left to do is place the edited version of the WpfModelViewApplicationProjectTemplateV0.1.cs.zip in the user project template location

TIP: Open VS2010 –> Tools –> Projects and Solutions for the directory path…

Restart VS2010 and now you have the project template available

If you found this article useful, please kick it on DotNetKicks.com

Posted by rudi | 5 comment(s)
Filed under: , ,

Creating a MVVM “Hello World” Application in 30 seconds

The WPF team finally released the WPF Model-View-ViewModel Toolkit, download it from here 

The Model-View-ViewModel toolkit is intended to introduce the Model-View-ViewModel design pattern for building WPF applications to the broad WPF developer community.

The toolkit includes:

  • A Visual Studio 2008 template (Visual C# Express 2008 also supported)
  • Documentation
    • General introduction to M-V-VM
    • Walkthrough using the VS template
  • A complete WPF application demonstrating the M-V-VM pattern

What’s is this MVVM?

Model-View-ViewModel (MVVM) is a derivative of MVC that takes advantage of particular strengths of the Windows Presentation Foundation (WPF) architecture to separate the Model and the View by introducing an abstract layer between them: a “Model of the View,” or ViewModel. The origins of this pattern are obscure, but it probably derives from the Smalltalk ApplicationModel pattern, as does the PresentationModel  pattern described by Martin Fowler. It was adapted for WPF use by the Expression team as they developed version 1 of Blend. Without the WPF-specific aspects, the Model-View-ViewModel pattern is identical with PresentationModel.

File –> New Project

Lets start by selecting the File –> New Project menu item within Visual Studio 2008.

This will bring up the “New Project” dialog. To create a new MVVM application, we’ll select the “WPF Model-View Application” project template on the right:

We’ll name the new project “MVVMDemo001”  and then click the “ok” button to create it.

When we click “ok”, Visual Studio will bring up an additional dialog that prompts us to optionally create a unit test project for the new application. This unit test project enables us to create automated tests that verify the functionality and behaviors of our application.

We will use the default “MVVMDemo001.Tests” name for the test project we create, and use the “Visual Studio Unit Test” framework option.  When we click the “ok” button Visual Studio will create a solution for us with two projects in it.

And that is it!

Lets take a closer look at what Visual Studio created for us:

Visual Studio created four top-level directories

  • Models
  • ViewModels
  • Views
  • Commands

We also receive some “pluming” code for ViewModelBase & DelegateCommand!

Under the hood

Visual Studio also create a default View/ViewModel and hook them up for us in the OnStartup!

public class MainViewModel : ViewModelBase
{
    
}

And here is the OnStartup

private void OnStartup(object sender, StartupEventArgs e)
{
    // Create the ViewModel and expose it using the View's DataContext
    Views.MainView view = new Views.MainView();
    view.DataContext = new ViewModels.MainViewModel();
    view.Show();
}

Conclusion

This is still a very early release of what thy are intending and we all are encourage to give some feedback!!! Try it out and let me know what you think of it…

Here is my wish list

  1. Mediator support
  2. Services (MessageBox, etc)
  3. Design Time Context Menus (Add View, Add ViewModel)

Definitely a step in the right direction so keep an eye on this project!!!

More information about MVVM

WPF Apps With The Model-View-ViewModel Design Pattern by Josh Smith

Other

If you found this article useful, please kick it on DotNetKicks.com

Dragging has NEVER been so easy

With Expression Blend 3, we now have support for behaviors. Behaviors makes creating really interactive applications extremely easy by encapsulating some of the common interactions!

Allowing element to be dragged on a canvas is now just one click away!

1. Create a new WPF application (Using VS or Blend)

2. Add reference to Microsoft.Expression.Interactivity (C:\Program Files\Microsoft Expression\Blend 3 Preview\Libraries\WPF)

NOTE: I am sure that in future versions of Expression Blend, the behaviors will be included but for now you either have to create your own or download the sample behaviors from http://gallery.expression.microsoft.com (Their is a WPF & Silverlight version)

3. Add the DragBehaviour to your application

public class DragBehavior : Behavior<UIElement>
{
    private bool isDragging = false;
    private UIElement attachedElement;
    private Window parent;

    Point lastPosition;
    TranslateTransform translatePosition;

    protected override void OnAttached()
    {
        attachedElement = this.AssociatedObject;
        parent = Application.Current.MainWindow;

        attachedElement.MouseLeftButtonDown += new MouseButtonEventHandler(MouseIsDown);
        attachedElement.MouseLeftButtonUp += new MouseButtonEventHandler(MouseIsUp);
        attachedElement.MouseMove += new MouseEventHandler(MouseIsMoving);
    }

    void MouseIsMoving(object sender, MouseEventArgs e)
    {
        if (isDragging)
        {
            Point currentPosition = e.GetPosition(parent);

            double dX = currentPosition.X - lastPosition.X;
            double dY = currentPosition.Y - lastPosition.Y;

            this.lastPosition = currentPosition;

            Transform oldTransform = attachedElement.RenderTransform;
            TransformGroup rt = new TransformGroup();
            TranslateTransform newPos = new TranslateTransform();
            newPos.X = dX;
            newPos.Y = dY;

            translatePosition = newPos;
            if (oldTransform != null)
            {
                rt.Children.Add(oldTransform);
            }
            rt.Children.Add(newPos);

            MatrixTransform mt = new MatrixTransform();
            mt.Matrix = rt.Value;

            attachedElement.RenderTransform = mt;
        }
    }

    void MouseIsUp(object sender, MouseButtonEventArgs e)
    {
        isDragging = false;

        attachedElement.ReleaseMouseCapture();
    }

    void MouseIsDown(object sender, MouseButtonEventArgs e)
    {
        isDragging = true;
        lastPosition = e.GetPosition(parent);
        attachedElement.CaptureMouse();
    }
}

4. Open the project in Expression Blend 3 and expand the Assets Library.

Their should be a DragBehavior under the behaviors tab, Drag the DragBehavior onto the element (on the design surface) you want to be drag-able (Confusing sentence)

5. This should add the following to your XAML

<Rectangle Width="55" Height="55">
    <e:Interaction.Behaviors>
        <local:DragBehavior/>
    </e:Interaction.Behaviors>
</Rectangle>

Caveat: The default namespace added by expression blend is wrong… I had to change it to the following

xmlns:e="clr-namespace:Microsoft.Expression.Interactivity;assembly=Microsoft.Expression.Interactivity" 

And that is it… Run this application and you should be able to drag the rectangle on the canvas

The sample pack from Microsoft has the following behaviors

  • DragBehavior
  • RandomMovementBehavior
  • TextBoxAutoSelectBehavior

For more information, watch session C22M - Creating Interactivity with Microsoft Expression Blend (By Peter Blois)

http://videos.visitmix.com/MIX09/C27M

UPDATE: Also read this article on the Expression Blend teams blog

If you found this useful or interesting, please kick it on DotNetKicks.com

Expression Blend 3 is…

AWESOME

Ok, that sounds a little cliché… but it really is! Here are some of my favorite new features

Effects

In the Asset Library there is a new tab item called Effects

By selecting one of these effects and dragging it onto any element in the design surface will apply this effect to the element!

And here is the XAML that gets generated

<Ellipse>
    <Ellipse.Effect>
        <DropShadowEffect/>
    </Ellipse.Effect>
</Ellipse>

PS. Also remember that by clicking on the DropShadowEffect in the Objects and Timeline pane, you can now use the property grid to set the effects properties!

IntelliSense

Blend finally has FULL intelliSense (Not just schema based)…

Perspective 3D with Projections

Silverlight now supports perspective 3D… This is extremely easy to setup using blend

Read more here

Import Adobe…

Adobe Illustrator

Photoshop

“You can now use Expression Blend 3 Preview to import both Adobe PhotoShop (.psd) files and Adobe Illustrator (.ai) files directly into your projects, while retaining layers, shapes, text elements, and more for easy editing inside Expression Blend itself. Note: Adobe live effects, blend modes, and the symbol sprayer are not supported. When you import an Adobe file, Expression Blend 3 Preview will display a message to let you know if any features of the imported file are not supported, and what actions you can take.”

Annotations

“Designers can now add visual bubble annotations (very similar to Microsoft Visio comments) to the artboard. These annotations are stored in the XAML file in the form of attached properties. They can be used to improve communication between team members. The annotations do not appear at runtime”

And their are MANY more

  • TFS Support
  • Behaviors
  • Sample Data
  • Some great new extensibility points
  • SketchFlow
  • Gradient tool improvements
  • Layout operation improvements

Get Expression Blend 3 here (289MB)

Other great resources:

If you found this article useful, please kick it on DotNetKicks.com

Posted by rudi | 7 comment(s)
Filed under:

Extract Properties To Style

XAML Power Toys

“XAML Power Toys is a Visual Studio 2008 SP1 Multi-AppDomain Add-In that empowers WPF & Silverlight developers while working in the XAML editor.  Its Line of Business form generation tools, Grid tools,  DataGrid and ListView generation really shorten the XAML page layout time.”

Karl has recently released a new version of XAML Power Toys… My favorite new feature is the “Extract Properties To Style”. Have a look at the following XAML:

<Button
    Foreground="Blue"
    Background="Yellow"
    BorderBrush="OliveDrab"
    BorderThickness="5"
    Margin="5,5,5,5"
    FontFamily="Times New Roman"
    FontSize="25"
    Width="200"
    Height="100">
    Click me
</Button>

Highlight the button in Visual Studio and right-click on it. In the context menu, select XAML Power Toys –> Extract Properties To Style

This will launch the Extract Selected Properties To Style dialog box… Here we can give our new style a name (MyFunnyButtonStyle) and we can also select which properties on our button should be placed in the style

Once we clicked on extract, the selected properties will be removed and the following style will be copied into the clipboard

<Style TargetType="{x:Type Button}" x:Key="MyFunnyButtonStyle">
    <Setter Property="Foreground" Value="Blue" />
    <Setter Property="Background" Value="Yellow" />
    <Setter Property="BorderBrush" Value="OliveDrab" />
    <Setter Property="BorderThickness" Value="5" />
    <Setter Property="Margin" Value="5,5,5,5" />
    <Setter Property="FontFamily" Value="Times New Roman" />
    <Setter Property="FontSize" Value="25" />
</Style>

Now we can easily re-use this style in all our other buttons!!!

 

 

 

If you found this useful, please kick it on DotNetKicks.com

Flexible layout on steroids

Have you tried PhotoSuru yet? Not yet? Check it out here

PhotoSuru is a sample .NET Framework 3.5 rich client photo-viewing experience which allows you to browse web-based photo collections anytime, anywhere in an intuitive, fluid and fun experience. With fast performance, optimized adaptive layout, and intuitive, simple navigation, this sample application highlights some of what is possible with .NET 3.5 SP1.

The reason why I ask this is because PhotoSuru takes flexible layout to the next level! If you run PhotoSuru and resize the window, check out how it dynamically show the appropriate view based on the size of the window! How do thy do that?

Introducing SizeTemplateControl

SizeTemplateControl - Control that allows a collection of ControlTemplates to be associated with it, to be applied based on size, and selects an appropriate template based on its layout size.

Under the covers PhotoSuru has a new control called SizeTemplateControl. This control has a collection of SizeControlTemplate

SizeControlTemplate - A class that allows to specify a ControlTemplate which is dependent of the Control’s size. Basically Min/Max Width/Height values specify an area for which the ControlTemplate is applicable.

Each SizeControlTemplate has a MinWidth, MinHeight, MaxWidth & MaxHeight at which it is appropriate to show its ControlTemplate. Here is a example of a ControlTemplate to be used if the current windows size is smaller than 800x350:

<ControlTemplate x:Key="SmallControlTemplate">
  
<!-- Omitted for brevity -->
</ControlTemplate>

Once we have all our ControlTemplates created, all that is left to do is give each one a minimum and maximum size

<sce:SizeTemplateControl>
    <sce:SizeTemplateControl.Templates>
        <sce:SizeControlTemplateCollection>
            <sce:SizeControlTemplate MinWidth="0" MinHeight="0" MaxWidth="800" MaxHeight="350" Template="{StaticResource SmallControlTemplate}" />
            <sce:SizeControlTemplate MinWidth="300" MinHeight="350" MaxWidth="1000"  Template="{StaticResource TallControlTemplate}" />
            <sce:SizeControlTemplate MinWidth="800" MaxHeight="455"  Template="{StaticResource TallControlTemplate}" />
            <sce:SizeControlTemplate MinWidth="1000" MinHeight="450" MaxHeight="650" Template="{StaticResource WideControlTemplate}" />
            <sce:SizeControlTemplate MinWidth="1000" MinHeight="650" MaxHeight="800" Template="{StaticResource MediumControlTemplate}" />
            <sce:SizeControlTemplate MinWidth="1000" MinHeight="800"  Template="{StaticResource LargeControlTemplate}" />
        </sce:SizeControlTemplateCollection>
    </sce:SizeTemplateControl.Templates>
</sce:SizeTemplateControl>

Now run this application and check out how it dynamically show different views (ControlTemplates) based on its Window size!!!

Download the source here

If you found this article useful, please kick it on DotNetKicks.com

For more information

The power of ICommand

“ICommand contains methods to execute commands. A command can be executed many times, and the parameter values can vary. This interface is mandatory on commands.”

The native support for the command pattern in WPF is great! It allows us to create very decoupled applications and in some instances even remove the need for a code-behind file completely.

WPF implement RoutedCommands & RoutedUICommands… Both of these are great for most scenarios but it still ties you to the visual tree. To completely decouple yourself from the visual tree, we need to explorer some custom implementations of the ICommand interface…

To test these great implementations, I created a application with a VERY basic “ViewModel”

This CustomerViewModel has 2 properties (Name & Surname). It also exposes a ICommand called Clean. If a View calls the Clean command, the name and surname should be set to string.empty! I know this is a overly simplified example but it shows how a View can communicate with the ViewModel in a completely decoupled way

Marlon Grech - SimpleCommand

Marlon created a excellent implementation called SimpleCommand. This truly lives up to its name… here is a example of how I would implement the Clean command using his implementation

Clean = new SimpleCommand()
{
    CanExecuteDelegate = x => Name != string.Empty || Surname != string.Empty,
    ExecuteDelegate = x => Name = Surname = string.Empty
};

Josh SmithRelayCommand

“RelayCommand allows you to inject the command's logic via delegates passed into its constructor. This approach allows for terse, concise command implementation in ViewModel classes. RelayCommand is a simplified variation of the DelegateCommand found in the .”

Josh also has a similar implementation

Clean = new RelayCommand(
    x => Name = Surname = string.Empty,
    x => Name != string.Empty || Surname != string.Empty
        ); 

PRISM team - DelegateCommand<T>

“The DelegateCommand allows delegating the commanding logic instead of requiring a handler in the code behind. It uses a delegate as the method of invoking a target handling method.”

Clean = new DelegateCommand<object>(
    x => Name = Surname = string.Empty,
    x => Name != string.Empty || Surname != string.Empty
        );

What I like about the PRISM team’s implementation is that it supports generics. It did however look like the DelegateCommand<T> did not fire its CanExecuteChanged event. From both Marlon & Josh’s implementations it looks thy are suppose to call CommandManager.RequerySuggested… but I am not sure (It might also be the IActiveAware stuff)

Conclusion

All three these implementations have two thing in common… Thy make it extremely easy to decouple your View and you ViewModel and thy encapsulate the command logic very cleanly!

If you found this article useful, please kick it on DotNetKicks.com

Must read articles about commands

Frameworks

History

Speaking at DevDays 2009

DevDays 2009 is less than 2 weeks away! If you haven’t registered yet, do so quickly because this is going to be a sold out event!

I will be presenting 2 sessions this year

WPF Demystified (Level 200)

Today's applications need to do more than simply work.  They need to draw the user in, and provide a differentiated experience. This means moving beyond battleship gray forms, boxy UIs, and providing a positive user experience. Windows Presentation Foundation (WPF) provides powerful capabilities to develop a compelling user interface, the kind that makes an application stand out.  In this session, we'll examine the core concepts of WPF such as layout panels, data binding, styles and control templates, and we'll use them to develop an application UI from the ground up.

Five Cool Things to Know and Use for Smart Client Development with Microsoft Visual Studio 2008 and the Microsoft .NET Framework 3.5 (Level 300)

While the world has gone overboard with building Web applications and many developers are focusing purely on the server-side, there are still huge opportunities for creating compelling rich client-based applications that play well in the software-plus-services world. With over 50 minutes of demo time, in this session we explore five new enhancements in Visual Studio 2008 and .NET Framework v3.5 for building smart Windows applications. Demonstrations include Windows Presentation Foundation interoperability, ADO.NET Sync Services, Client Application Services, the Managed Extensibility Framework, and customizing Office Applications (Visual Studio Tools for the Microsoft Office System v3.0).

Hope to see you their…

Posted by rudi | with no comments
Filed under: , ,

Fun with Silverlight Toolkit Charts

The last couple of weeks I have been playing with the Silverlight Toolkit’s chart controls! These controls are incredibly powerful (and free)

The Silverlight Toolkit is a collection of Silverlight controls, components and utilities made available outside the normal Silverlight release cycle. It adds new functionality quickly for designers and developers, and provides the community an efficient way to help shape product development by contributing ideas and bug reports. It includes full source code, unit tests, samples and documentation for 12 new controls covering charting, styling, layout, and user input.

I’ve written 2 CodeProject articles about some of the cool stuff these controls can do

Styling a Silverlight Chart

In this article I detail step by step how to restyle a line chart to look similar to the Google Analytics charts

How to create stock charts using Silverlight Toolkit

And in my latest article, I explorer how to add financial/stock data into a chart (by creating a candlestick chart)

 

For a more detailed list of Silverlight Toolkit resources, check out this list on David Anson’s blog

kick it on DotNetKicks.com

Major update to WPF Themes

I am super-excited (Official Microsoft Terminology) about the new release of WPF Themes! The WPF Themes project now have 18 themes and support most of the “out-of-the-box” controls available in WPF! Here is a quick overview of what is new:

 

  • 18 Themes (Added WhistlerBlue & BureauBlack)
  • New Controls (Expander, TreeView & TabControl)
  • Compatible with new WPF Toolkit January 2009 (3.5.40128.1)

Thank you for all the support and feedback…

kick it on DotNetKicks.com
Posted by rudi | 12 comment(s)
Filed under:
More Posts Next page »