CompositeWPFContrib Wiki & Documentation Rss Feed

Updated Wiki: Home

ejadib — Sun, 26 Oct 2008 16:45:06 GMT

Welcome to the Composite WPF Contrib project

Composite WPF Contrib is a community-developed library of extensions to the patterns & practices Composite WPF project.

If you are building custom tools and extensions and want to share them then Composite WPF Contrib will get it out to the masses.
If you've got a great idea for new extensions Composite WPF contrib is the place to find developers ready, willing, and able to make it happen.
If you use Composite WPF within your org, then Composite WPF Contrib is the place to find tools and extensions to add to your arsenal.
If you want to connect with others who are pushing the bar on Prism development, then Prism Contrib is the place to be.

Prism contrib is about YOU. With your help we can make it a vibrant resource for WPF Composite developers world-wide.

News

(2008-10-26) New Extensions

WindowRegionAdapter. It provides a way to show views in separate windows.

(2008-10-16) New Extensions

SimpleUnityBootstrapper and CompositeEvent. Allows you to use modular loading and pub-sub events in Windows Forms or other application types. Also a sample application showing how to use the container to achieve Region-like functionality in Windows Forms. See blog post at Brian Noyes Blog for more detailed description.

(2008-10-04) New Extensions

Windsor adapter and bootstrapper. Allows you to use Castle Windsor IoC with CompositeWPF.
Log4Net logger. Used by Windsor adapter can be used to log debug and trace info using Log4Net library.

(2008-09-13) New Sample

Presentation Model with DataTemplates in CompositeWPF

(2008-09-07) New Sample

WPF Quickstart shipped with the Smart Client Software Factory regenerated using the Composite Application Guidance for WPF.

(2008-09-05) New Extensions

DialogWorkspace Show any view as a dialog in your application. Sample is included.

(2008-08-11) New Sample

Sample application that demonstrate how to use the Disconnected Service Agent Application Block with CompositeWPF

(2008-07-31) New Extensions

TabGroupPaneRegionAdapter. Infragistics TabGroupPane Region Adapter for CompositeWPF

(2008-07-25) New Extensions

ExtendedModuleLoaderService. Extended module loader service with support to install modules on demand using windows installer

(2008-07-21) New Extensions

OutlookBar. OutlookBar control and region adapter for CompositeWPF

(2008-07-17) New Extensions

Module Status Service. The Module Status Service can be used to retrieve information about what modules are loaded

(2008-07-11) New Extensions

CompositeModuleEnumerator. The CompositeModuleEnumerator makes it possible to combine several module enumerator instances into one module enumerator.
ToolBarPanelRegionAdapter. This adapter adapts control of type System.Windows.Controls.Primitives.ToolBarPanel and derived classes.

(2008-07-08) New Visual Studio Templates. The goal of these templates is to help users start with the Composite WPF project.

What's in Prism Contrib?

SimpleUnityBootstrapper and CompositeEvent allowing using of modular loading and events in Windows Forms or other application types
Spring.NET adapter and extensions for CompositeWPF
Castle Windsor adapter and extensions for CompositeWPF
PrismAG - Composite WPF for Silverlight
OutlookBar - OutlookBar control and region adapter for CompositeWPF
CompositeModuleEnumerator - Composite Module Enumerator
Module Status Service - A service that can be used to retrieve information about what modules are loaded
Extended Module Service - An extended module loader service with support to install modules on demand using windows installer
Visual Studio Templates
Composite WPF Extensions - Add-on commands, services, regions, etc to aid you in your Composite WPF development
Infragistics Extensions - Infragistics Extensions for CompositeWPF
Samples

See the Documentation index for information on how to use each of these extensions and components.

Contributing to Composite WPF Contrib

Would you like to join as a developer of the Composite WPF Contrib project to share your own extensions or improve the existing codebase? Great! Here is what you need to know

Other p&p Contrib Projects

Updated Wiki: Windows Region Adapter

ejadib — Sun, 26 Oct 2008 16:44:25 GMT

Window Region Adapter

The WindowRegionAdapter provides a way to show views in separate windows with a custom style:

Important Features

It uses a SingleActiveRegion, so that only one (or no) view (one window) is active at a time.
It provides a WindowStyle property (of type Style) which allows the developer to specify a custom style to use as a template for all the windows shown in the region.

How to use

1 - Register the adapter mapping for the Region Adapter for the type Window:

protected override RegionAdapterMappings ConfigureRegionAdapterMappings() 
{ 
    RegionAdapterMappings regionAdapterMappings = Container.TryResolve<RegionAdapterMappings>();
    if (regionAdapterMappings != null) 
    { 
        regionAdapterMappings.RegisterMapping(typeof(Window), new WindowRegionAdapter()); 
    }
    return base.ConfigureRegionAdapterMappings(); 
}

Recommended: Provide a custom style to use as template for all the windows shown in the region by setting its WindowStyle property on initialization:

regionAdapterMappings.RegisterMapping(typeof(Window), new WindowRegionAdapter() { WindowStyle = (Style 
Application.Current.FindResource("WindowTemplate") });

2 - Add the cal:RegionManager.RegionName attribute to a Window (for example, the Shell window) to set the owner for the child windows, as follows:

<Window x:Class="Example.Shell" 
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
xmlns:cal="http://www.codeplex.com/CompositeWPF" 
Title="MainWindow" Height="400" Width="500" WindowStartupLocation="CenterScreen" 
cal:RegionManager.RegionName="MyWindowRegion">

3 - Display a view as follows:

MyViewPresenter myViewPresenter = myContainer.Resolve<MyViewPresenter>();
_regionManager.Regions["MyWindowRegion"].Add(myViewPresenter.View);

More Information

For more information and a sample application, you may visit WindowRegionAdapter for CompositeWPF (Prism).

Updated Wiki: Documentation

ejadib — Sun, 26 Oct 2008 16:43:54 GMT

Documentation

Updated Wiki: Windows Region Adapter

ejadib — Sun, 26 Oct 2008 16:40:26 GMT

The WindowRegionAdapter

The WindowRegionAdapter provides a way to show views in separate windows with a custom style:

Important Features

It uses a SingleActiveRegion, so that only one (or no) view (one window) is active at a time.
It provides a WindowStyle property (of type Style) which allows the developer to specify a custom style to use as a template for all the windows shown in the region.

How to use

1 - Register the adapter mapping for the Region Adapter for the type Window:

protected override RegionAdapterMappings ConfigureRegionAdapterMappings() 
{ 
    RegionAdapterMappings regionAdapterMappings = Container.TryResolve<RegionAdapterMappings>();
    if (regionAdapterMappings != null) 
    { 
        regionAdapterMappings.RegisterMapping(typeof(Window), new WindowRegionAdapter()); 
    }
    return base.ConfigureRegionAdapterMappings(); 
}

Recommended: Provide a custom style to use as template for all the windows shown in the region by setting its WindowStyle property on initialization:

regionAdapterMappings.RegisterMapping(typeof(Window), new WindowRegionAdapter() { WindowStyle = (Style 
Application.Current.FindResource("WindowTemplate") });

2 - Add the cal:RegionManager.RegionName attribute to a Window (for example, the Shell window) to set the owner for the child windows, as follows:

<Window x:Class="Example.Shell" 
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
xmlns:cal="http://www.codeplex.com/CompositeWPF" 
Title="MainWindow" Height="400" Width="500" WindowStartupLocation="CenterScreen" 
cal:RegionManager.RegionName="MyWindowRegion">

3 - Display a view as follows:

MyViewPresenter myViewPresenter = myContainer.Resolve<MyViewPresenter>();
_regionManager.Regions["MyWindowRegion"].Add(myViewPresenter.View);

More Information

For more information and a sample application, you may visit WindowRegionAdapter for CompositeWPF (Prism).

Updated Wiki: Documentation

ejadib — Sun, 26 Oct 2008 16:35:29 GMT

Documentation

Updated Wiki: Documentation

ejadib — Sun, 26 Oct 2008 16:34:59 GMT

Documentation

Updated Wiki: Home

ejadib — Sun, 26 Oct 2008 16:33:37 GMT

Welcome to the Composite WPF Contrib project

Composite WPF Contrib is a community-developed library of extensions to the patterns & practices Composite WPF project.

If you are building custom tools and extensions and want to share them then Composite WPF Contrib will get it out to the masses.
If you've got a great idea for new extensions Composite WPF contrib is the place to find developers ready, willing, and able to make it happen.
If you use Composite WPF within your org, then Composite WPF Contrib is the place to find tools and extensions to add to your arsenal.
If you want to connect with others who are pushing the bar on Prism development, then Prism Contrib is the place to be.

Prism contrib is about YOU. With your help we can make it a vibrant resource for WPF Composite developers world-wide.

News

(2008-10-26) New Extensions

WindowsRegionAdapter. It provides a way to show views in separate windows.

(2008-10-16) New Extensions

SimpleUnityBootstrapper and CompositeEvent. Allows you to use modular loading and pub-sub events in Windows Forms or other application types. Also a sample application showing how to use the container to achieve Region-like functionality in Windows Forms. See blog post at Brian Noyes Blog for more detailed description.

(2008-10-04) New Extensions

Windsor adapter and bootstrapper. Allows you to use Castle Windsor IoC with CompositeWPF.
Log4Net logger. Used by Windsor adapter can be used to log debug and trace info using Log4Net library.

(2008-09-13) New Sample

Presentation Model with DataTemplates in CompositeWPF

(2008-09-07) New Sample

WPF Quickstart shipped with the Smart Client Software Factory regenerated using the Composite Application Guidance for WPF.

(2008-09-05) New Extensions

DialogWorkspace Show any view as a dialog in your application. Sample is included.

(2008-08-11) New Sample

Sample application that demonstrate how to use the Disconnected Service Agent Application Block with CompositeWPF

(2008-07-31) New Extensions

TabGroupPaneRegionAdapter. Infragistics TabGroupPane Region Adapter for CompositeWPF

(2008-07-25) New Extensions

ExtendedModuleLoaderService. Extended module loader service with support to install modules on demand using windows installer

(2008-07-21) New Extensions

OutlookBar. OutlookBar control and region adapter for CompositeWPF

(2008-07-17) New Extensions

Module Status Service. The Module Status Service can be used to retrieve information about what modules are loaded

(2008-07-11) New Extensions

CompositeModuleEnumerator. The CompositeModuleEnumerator makes it possible to combine several module enumerator instances into one module enumerator.
ToolBarPanelRegionAdapter. This adapter adapts control of type System.Windows.Controls.Primitives.ToolBarPanel and derived classes.

(2008-07-08) New Visual Studio Templates. The goal of these templates is to help users start with the Composite WPF project.

What's in Prism Contrib?

SimpleUnityBootstrapper and CompositeEvent allowing using of modular loading and events in Windows Forms or other application types
Spring.NET adapter and extensions for CompositeWPF
Castle Windsor adapter and extensions for CompositeWPF
PrismAG - Composite WPF for Silverlight
OutlookBar - OutlookBar control and region adapter for CompositeWPF
CompositeModuleEnumerator - Composite Module Enumerator
Module Status Service - A service that can be used to retrieve information about what modules are loaded
Extended Module Service - An extended module loader service with support to install modules on demand using windows installer
Visual Studio Templates
Composite WPF Extensions - Add-on commands, services, regions, etc to aid you in your Composite WPF development
Infragistics Extensions - Infragistics Extensions for CompositeWPF
Samples

See the Documentation index for information on how to use each of these extensions and components.

Contributing to Composite WPF Contrib

Would you like to join as a developer of the Composite WPF Contrib project to share your own extensions or improve the existing codebase? Great! Here is what you need to know

Other p&p Contrib Projects

Updated Wiki: Home

BrianNoyes — Thu, 16 Oct 2008 15:36:16 GMT

Welcome to the Composite WPF Contrib project

Composite WPF Contrib is a community-developed library of extensions to the patterns & practices Composite WPF project.

If you are building custom tools and extensions and want to share them then Composite WPF Contrib will get it out to the masses.
If you've got a great idea for new extensions Composite WPF contrib is the place to find developers ready, willing, and able to make it happen.
If you use Composite WPF within your org, then Composite WPF Contrib is the place to find tools and extensions to add to your arsenal.
If you want to connect with others who are pushing the bar on Prism development, then Prism Contrib is the place to be.

Prism contrib is about YOU. With your help we can make it a vibrant resource for WPF Composite developers world-wide.

News

(2008-10-16) New Extensions

SimpleUnityBootstrapper and CompositeEvent. Allows you to use modular loading and pub-sub events in Windows Forms or other application types. Also a sample application showing how to use the container to achieve Region-like functionality in Windows Forms. See blog post at Brian Noyes Blog for more detailed description.

(2008-10-04) New Extensions

Windosr adapter and bootstrapper. Allows you to use Castle Windsor IoC with CompositeWPF.
Log4Net logger. Used by Windsor adapter can be used to log debug and trace info using Log4Net library.

(2008-09-13) New Sample

Presentation Model with DataTemplates in CompositeWPF

(2008-09-07) New Sample

WPF Quickstart shipped with the Smart Client Software Factory regenerated using the Composite Application Guidance for WPF.

(2008-09-05) New Extensions

DialogWorkspace Show any view as a dialog in your application. Sample is included.

(2008-08-11) New Sample

Sample application that demonstrate how to use the Disconnected Service Agent Application Block with CompositeWPF

(2008-07-31) New Extensions

TabGroupPaneRegionAdapter. Infragistics TabGroupPane Region Adapter for CompositeWPF

(2008-07-25) New Extensions

ExtendedModuleLoaderService. Extended module loader service with support to install modules on demand using windows installer

(2008-07-21) New Extensions

OutlookBar. OutlookBar control and region adapter for CompositeWPF

(2008-07-17) New Extensions

Module Status Service. The Module Status Service can be used to retrieve information about what modules are loaded

(2008-07-11) New Extensions

CompositeModuleEnumerator. The CompositeModuleEnumerator makes it possible to combine several module enumerator instances into one module enumerator.
ToolBarPanelRegionAdapter. This adapter adapts control of type System.Windows.Controls.Primitives.ToolBarPanel and derived classes.

(2008-07-08) New Visual Studio Templates. The goal of these templates is to help users start with the Composite WPF project.

What's in Prism Contrib?

SimpleUnityBootstrapper and CompositeEvent allowing using of modular loading and events in Windows Forms or other application types
Spring.NET adapter and extensions for CompositeWPF
Castle Windsor adapter and extensions for CompositeWPF
PrismAG - Composite WPF for Silverlight
OutlookBar - OutlookBar control and region adapter for CompositeWPF
CompositeModuleEnumerator - Composite Module Enumerator
Module Status Service - A service that can be used to retrieve information about what modules are loaded
Extended Module Service - An extended module loader service with support to install modules on demand using windows installer
Visual Studio Templates
Composite WPF Extensions - Add-on commands, services, regions, etc to aid you in your Composite WPF development
Infragistics Extensions - Infragistics Extensions for CompositeWPF
Samples

See the Documentation index for information on how to use each of these extensions and components.

Contributing to Composite WPF Contrib

Would you like to join as a developer of the Composite WPF Contrib project to share your own extensions or improve the existing codebase? Great! Here is what you need to know

Other p&p Contrib Projects

Updated Wiki: WindsorAndLog4Net

HEskandari — Sat, 04 Oct 2008 09:16:51 GMT

Windsor Bootstrapper and Log4Net

Introduction

CompositeWPF comes uses Unity as default dependency injection container, but you can replace the default container and use other containers too. Here we see how to use Castle Windsor container and use Log4Net library as our logging mechanism.

Using Boostrapper

There is an abstract WindsorBootstrapper which you need to inherit from :

public class Bootstrapper : WindsorBootstrapper
{
    private IWindsorContainer container;
 
    public Bootstrapper() : this(new WindsorContainer())
    {
    }
 
    public Bootstrapper(IWindsorContainer container)
    {
        this.container = container;
    }
 
    protected override IWindsorContainer CreateContainer()
    {
        return container;
    }
}

After when interfacing with IWindsorContainer, you can use generic extension methods provided to you in WindsorContainerExtensions class :

using CompositeWPFContrib.Composite.WindsorExtensions;
 
[Singleton]
public class OrderService : IOrderService
{
    public void AcceptOrder(string orderName)
    {
        var serviceInstance = Container.TryResolve<IOrderProcessService>();
        serviceInstance.Process(orderName);
    }
}

Using Log4Net Logger

When using WindsorBootstrapper, an instance of ILoggerFacade implemented using Log4Net is already registered for you. To start logging, all you need is to configure Log4Net, either with configuration files or via code when starting the application, and later get an instance of ILoggerFacade, either via Constructor injection or Service Lookup, and perform the actual logging. Please note that, since Log4Net does not have a notion of Priorities and only supports Categories when logging, all the specified priorities will be ignored.

[Singleton]
public class OrderService : IOrderService
{
    private ILoggerFacade logger;
    private IWindsorContainer container;
 
    public OrderService(IWindsorContainer container, ILoggerFacade logger)
    {
        this.container = container;
        this.logger = logger;
    }
 
    public void AcceptOrder(string orderName)
    {
        logger.Log("Getting Order Process service", Category.Debug, Priority.High);
        var serviceInstance = container.TryResolve<IOrderProcessService>();
 
        logger.Log("Processing the order", Category.Info, Priority.Low);
        serviceInstance.Process(orderName);
    }
}

Using Windsor Adapter

When using CompositeWPF, there are a lot of times when you need to interact with the IoC container. To avoid coupling to specific container, you'd better stick to IContainerFacade implementation provided to you. This will help a lot in case you need to switch to another IoC container. When using WindsorBootstrapper an instance of IContainerFacade implemented using Windsor is registered for you. So, instead of using IWindsorContainer interface or implementation directly, it is advised to use IContainerFacade :

[Singleton]
public class OrderService : IOrderService
{
    private IContainerFacade container;
 
    public OrderService(IContainerFacade container)
    {
        this.container = container;
    }
 
    public void AcceptOrder(string orderName)
    {
        var serviceInstance = container.TryResolve(typeof(IOrderProcessService));
        serviceInstance.Process(orderName);
    }
}

Updated Wiki: WindsorAndLog4Net

HEskandari — Sat, 04 Oct 2008 09:15:09 GMT

Windsor Bootstrapper and Log4Net

Introduction

Using Boostrapper

There is an abstract WindsorBootstrapper which you need to inherit from :

public class Bootstrapper : WindsorBootstrapper
{
    private IWindsorContainer container;
 
    public Bootstrapper() : this(new WindsorContainer())
    {
    }
 
    public Bootstrapper(IWindsorContainer container)
    {
        this.container = container;
    }
 
    protected override IWindsorContainer CreateContainer()
    {
        return container;
    }
}

After when interfacing with IWindsorContainer, you can use generic extension methods provided to you in WindsorContainerExtensions class :

using CompositeWPFContrib.Composite.WindsorExtensions;
 
[Singleton]
public class OrderService : IOrderService
{
    public void AcceptOrder(string orderName)
    {
        var serviceInstance = Container.TryResolve<IOrderProcessService>();
        serviceInstance.Process(orderName);
    }
}

Using Log4Net Logger

[Singleton]
public class OrderService : IOrderService
{
    private ILoggerFacade logger;
    private IWindsorContainer container;
 
    public OrderService(IWindsorContainer container, ILoggerFacade logger)
    {
        this.container = container;
        this.logger = logger;
    }
 
    public void AcceptOrder(string orderName)
    {
        logger.Log("Getting Order Process service", Category.Debug, Priority.High);
        var serviceInstance = container.TryResolve<IOrderProcessService>();
 
        logger.Log("Processing the order", Category.Info, Priority.Low);
        serviceInstance.Process(orderName);
    }
}

Using Windsor Adapter

When using CompositeWPF, there are a lot of times when you need to interact with the IoC container. To avoid coupling to specific container, you'd better stick to IContainerFacade implementation provided to you. This will help a lot in case you need to switch to another container. When using WindsorBootstrapper an instance of IContainerFacade implemented using Windsor is registered for you. So, instead of using IWindsorContainer interface or implementation directly, it is advised to use IContainerFacade :

[Singleton]
public class OrderService : IOrderService
{
    private IContainerFacade container;
 
    public OrderService(IContainerFacade container)
    {
        this.container = container;
    }
 
    public void AcceptOrder(string orderName)
    {
        var serviceInstance = container.TryResolve(typeof(IOrderProcessService));
        serviceInstance.Process(orderName);
    }
}

Updated Wiki: Documentation

HEskandari — Sat, 04 Oct 2008 07:16:29 GMT

Documentation

Updated Wiki: Home

HEskandari — Sat, 04 Oct 2008 07:12:57 GMT

Welcome to the Composite WPF Contrib project

Composite WPF Contrib is a community-developed library of extensions to the patterns & practices Composite WPF project.

If you are building custom tools and extensions and want to share them then Composite WPF Contrib will get it out to the masses.
If you've got a great idea for new extensions Composite WPF contrib is the place to find developers ready, willing, and able to make it happen.
If you use Composite WPF within your org, then Composite WPF Contrib is the place to find tools and extensions to add to your arsenal.
If you want to connect with others who are pushing the bar on Prism development, then Prism Contrib is the place to be.

Prism contrib is about YOU. With your help we can make it a vibrant resource for WPF Composite developers world-wide.

News

(2008-10-04) New Extensions

Windosr adapter and bootstrapper. Allows you to use Castle Windsor IoC with CompositeWPF.
Log4Net logger. Used by Windsor adapter can be used to log debug and trace info using Log4Net library.

(2008-09-13) New Sample

Presentation Model with DataTemplates in CompositeWPF

(2008-09-07) New Sample

WPF Quickstart shipped with the Smart Client Software Factory regenerated using the Composite Application Guidance for WPF.

(2008-09-05) New Extensions

DialogWorkspace Show any view as a dialog in your application. Sample is included.

(2008-08-11) New Sample

Sample application that demonstrate how to use the Disconnected Service Agent Application Block with CompositeWPF

(2008-07-31) New Extensions

TabGroupPaneRegionAdapter. Infragistics TabGroupPane Region Adapter for CompositeWPF

(2008-07-25) New Extensions

ExtendedModuleLoaderService. Extended module loader service with support to install modules on demand using windows installer

(2008-07-21) New Extensions

OutlookBar. OutlookBar control and region adapter for CompositeWPF

(2008-07-17) New Extensions

Module Status Service. The Module Status Service can be used to retrieve information about what modules are loaded

(2008-07-11) New Extensions

CompositeModuleEnumerator. The CompositeModuleEnumerator makes it possible to combine several module enumerator instances into one module enumerator.
ToolBarPanelRegionAdapter. This adapter adapts control of type System.Windows.Controls.Primitives.ToolBarPanel and derived classes.

(2008-07-08) New Visual Studio Templates. The goal of these templates is to help users start with the Composite WPF project.

What's in Prism Contrib?

Spring.NET adapter and extensions for CompositeWPF
Castle Windsor adapter and extensions for CompositeWPF
PrismAG - Composite WPF for Silverlight
OutlookBar - OutlookBar control and region adapter for CompositeWPF
CompositeModuleEnumerator - Composite Module Enumerator
Module Status Service - A service that can be used to retrieve information about what modules are loaded
Extended Module Service - An extended module loader service with support to install modules on demand using windows installer
Visual Studio Templates
Composite WPF Extensions - Add-on commands, services, regions, etc to aid you in your Composite WPF development
Infragistics Extensions - Infragistics Extensions for CompositeWPF
Samples

See the Documentation index for information on how to use each of these extensions and components.

Contributing to Composite WPF Contrib

Would you like to join as a developer of the Composite WPF Contrib project to share your own extensions or improve the existing codebase? Great! Here is what you need to know

Other p&p Contrib Projects

Updated Wiki: Home

ejadib — Sat, 13 Sep 2008 20:36:38 GMT

Welcome to the Composite WPF Contrib project

Composite WPF Contrib is a community-developed library of extensions to the patterns & practices Composite WPF project.

If you are building custom tools and extensions and want to share them then Composite WPF Contrib will get it out to the masses.
If you've got a great idea for new extensions Composite WPF contrib is the place to find developers ready, willing, and able to make it happen.
If you use Composite WPF within your org, then Composite WPF Contrib is the place to find tools and extensions to add to your arsenal.
If you want to connect with others who are pushing the bar on Prism development, then Prism Contrib is the place to be.

Prism contrib is about YOU. With your help we can make it a vibrant resource for WPF Composite developers world-wide.

News

(2008-09-13) New Sample

Presentation Model with DataTemplates in CompositeWPF

(2008-09-07) New Sample

WPF Quickstart shipped with the Smart Client Software Factory regenerated using the Composite Application Guidance for WPF.

(2008-09-05) New Extensions

DialogWorkspace Show any view as a dialog in your application. Sample is included.

(2008-08-11) New Sample

Sample application that demonstrate how to use the Disconnected Service Agent Application Block with CompositeWPF

(2008-07-31) New Extensions

TabGroupPaneRegionAdapter. Infragistics TabGroupPane Region Adapter for CompositeWPF

(2008-07-25) New Extensions

ExtendedModuleLoaderService. Extended module loader service with support to install modules on demand using windows installer

(2008-07-21) New Extensions

OutlookBar. OutlookBar control and region adapter for CompositeWPF

(2008-07-17) New Extensions

Module Status Service. The Module Status Service can be used to retrieve information about what modules are loaded

(2008-07-11) New Extensions

CompositeModuleEnumerator. The CompositeModuleEnumerator makes it possible to combine several module enumerator instances into one module enumerator.
ToolBarPanelRegionAdapter. This adapter adapts control of type System.Windows.Controls.Primitives.ToolBarPanel and derived classes.

(2008-07-08) New Visual Studio Templates. The goal of these templates is to help users start with the Composite WPF project.

What's in Prism Contrib?

PrismAG - Composite WPF for Silverlight
OutlookBar - OutlookBar control and region adapter for CompositeWPF
CompositeModuleEnumerator - Composite Module Enumerator
Module Status Service - A service that can be used to retrieve information about what modules are loaded
Extended Module Service - An extended module loader service with support to install modules on demand using windows installer
Visual Studio Templates
Composite WPF Extensions - Add-on commands, services, regions, etc to aid you in your Composite WPF development
Infragistics Extensions - Infragistics Extensions for CompositeWPF
Samples

See the Documentation index for information on how to use each of these extensions and components.

Contributing to Composite WPF Contrib

Would you like to join as a developer of the Composite WPF Contrib project to share your own extensions or improve the existing codebase? Great! Here is what you need to know

Other p&p Contrib Projects

Updated Wiki: WPFQuickstartRegeneratedWithCAL

mconverti — Mon, 08 Sep 2008 13:53:57 GMT

Download pdf version of this document

Regenerating the WPF/SC-SF Quickstart with the Composite Application Library

The Composite Application Guidance for WPF (Prism) is a set of assets for developing Composite WPF applications that addresses the challenges around building complex enterprise WPF applications. It is not a new version of Composite UI Application Block (CAB) but the concepts of Modularity (composition), Services, Dependency Injection, and Event Brokering are also present in this new guidance because they are essential for building composite applications. However, their manifestations are very different than what you see in CAB.

Purpose
Prerequisites
Application Structure
Creating the initial solution

Preparing the Shell

Creating Modules
Creating Views
Checking the Results

Purpose

In this article, you will see how the WPF Quickstart shipped with the Smart Client Software Factory was regenerated using the Composite Application Guidance for WPF. It includes guidance about how to create the initial solution from scratch, identify the regions, use the Event Aggregator service and load modules.

Prerequisites

This topic requires you to have the following Composite Application Library and Unity Application Block assemblies:

Microsoft.Practices.Composite.dll
Microsoft.Practices.Composite.Wpf.dll
Microsoft.Practices.Composite.UnityExtensions.dll
Microsoft.Practices.Unity.dll
Microsoft.Practices.ObjectBuilder2.dll

The Composite Application Library ships as source code, which means you must compile it to get the Composite Application Library assemblies.

Application Structure

Both the Composite Application Library and Composite UI Application Block applications have similar solution structure with the following components:

An startup project that contains the shell view that defines the layout
Modules that add views, services, and other functionalities
[Optionally] Infrastructure projects to share common artifacts and constants definitions.

The following figure shows the equivalent elements between the original WPF Quickstart shipped with the SCSF source code and the WPF Quickstart rewritten to use the Composite Application Library.

Figure 1
Solution structure

Creating the initial solution

To be able to use the features of the Composite Application Library, you will need to create a pure WPF Application. To do this, follow these steps:

In Visual Studio, create a new WPF application named WPFQuickstartwithCAL.
Add the Common and Modules solution folders to the WPFQuickstartwithCAL solution.
Create a new Class Library project in the Common solution folder called WPFQuickstartwithCAL.Infrastructure.

Note: In this project you will place common components like constants and events definitions. This is just a good practice but it is not required.

Add the Constants and Events folders to the WPFQuickstartwithCAL.Infrastructure project.
Add the RegionNames class to the Constants folder and put there the definition of the following constants:

public const string RightRegion = "RightRegion";
public const string LeftRegion = "LeftRegion";

These constants are used to identify regions throughout the application. A region is a mechanism that allows you to expose to the application Windows Presentation Foundation controls as components that encapsulate a particular visual way of displaying views. Regions can be accessed in a decoupled way by their name and they support adding or removing views dynamically at run time

Add the ShowEmployeeEvent class to the Events folder with the following event definition:

public class ShowEmployeeEvent : CompositeWpfEvent<int>
{
}

Note: All the modules of the final solution have a reference to the WPFQuickstartwithCAL.Infrastructure project.

Preparing the Shell

The application starting point is a WPF Application project which contains a Shell, a Bootstrapper class and a App.xaml file. The following is a description of these artifacts:

Shell: A Composite WPF application should contain a place to host different UI components that exposes a way for itself to be populated by others. The following is the Shell used in this solution:

Figure 2
Application’s Shell

The cal:RegionManager.RegionName attribute added to the control is an attached property which indicates that a region has to be created and associated with the control when the view is being built. The value of this attribute is set with the name of the region defined in the RegionNames class.

Bootstrapper class: This class inherits from UnityBootstrapper and is in charge of initializing the application. The Bootstrapper is responsible for:

Initialize the container (UnityBootstrapper base class uses the Unity container).
Register core services, like the RegionManager (it is used to get regions) and the EventAggregator (it is used to implement event brokering).
Register adapters for the region that the application uses.
Create and shows the shell.
Load the modules.

Note: The Composite Application Library allows you to choose the way that your modules are loaded (dynamically or statically). By using static module loading, like this sample, the code is simplified and improves the application startup performance.

internal class Bootstrapper : UnityBootstrapper
{
    protected override IModuleEnumerator GetModuleEnumerator()
    {
        return new StaticModuleEnumerator()
            .AddModule(typeof(EmployeeDataModule))
            .AddModule(typeof(OrganizationChartModule));
    }
 
    protected override DependencyObject CreateShell()
    {
        Shell shell = new Shell();
        shell.Show();
 
        return shell;
    }
}

App.xaml file: The OnStartup method of the App class is overridden to create and initialize the Bootstrapper class.

protected override void OnStartup(StartupEventArgs e)
{
    base.OnStartup(e);
 
    Bootstrapper bootstrapper = new Bootstrapper();
    bootstrapper.Run();
}

Creating Modules

A module is a class library project that must have a class witch implements the IModule interface. This interface has a single method: the Initialize method. In this method you should register services, views and presenters in the container. It is also where you should create views and add them to the Shell’s regions.
The WPF Quickstart has the following modules:

WPFQuickstartwithCAL.EmployeeData: In this module are placed the view that shows information about an employee (which is shown in the Right region of the Shell) and a service that retrieves data about employees. The following code shows the implementation of the EmployeeDataModule class.

public class EmployeeDataModule : IModule
{
    private IUnityContainer container;
    private IRegionManager regionManager;
 
    public EmployeeDataModule(IUnityContainer container, IRegionManager regionManager)
    {
        this.container = container;
        this.regionManager = regionManager;
    }
 
    public void Initialize()
    {
        this.RegisterViewsAndServices();
 
        EmployeePresenter presenter = this.container.Resolve<EmployeePresenter>();
 
        IRegion mainRegion = this.regionManager.Regions[RegionNames.RightRegion];
        mainRegion.Add(presenter.View);
    }
 
    protected void RegisterViewsAndServices()
    {
        this.container.RegisterType<IEmployeeView, EmployeeView>();
    }
}

WPFQuickstartwithCAL.OrganizationChart: In this module are placed the view that shows the organization chart. The view is showed in the Left region of the Shell. The following code shows the implementation of the OrganizationChartModule class.

public class OrganizationChartModule : IModule
{
    private IUnityContainer container;
    private IRegionManager regionManager;
 
    public OrganizationChartModule(IUnityContainer container, IRegionManager regionManager)
    {
        this.container = container;
        this.regionManager = regionManager;
    }
 
    public void Initialize()
    {
        this.RegisterViewsAndServices();
 
        OrgChartPresenter presenter = this.container.Resolve<OrgChartPresenter>();
 
        IRegion mainRegion = this.regionManager.Regions[RegionNames.LeftRegion];
        mainRegion.Add(presenter.View);
    }
 
    protected void RegisterViewsAndServices()
    {
        this.container.RegisterType<IOrgChartView, OrgChartView>();
    }
}

The Figure 3 shows the structure of the two modules in the solution explorer.

Figure 3
Modules structure

Creating Views

All the views are WPF User Controls. To implement the view logic this sample implements the Model-View-Presenter pattern.
In the MVP implementation of CAB/SC-SF, the presenter has a reference to the view interface and the view also has a reference to its presenter. But in the MVP implementation of a Composite WPF application the view usually does not have a reference to its presenter. The communication between the view and its presenter is achieved by using .NET events.
Another difference is that in CAB/SC-SF you created the view and the presenter was injected on it. In a Composite WPF application, the presenter usually drives all the interaction, so the presenters are created using the container (by the Resolve method) and receives a view passed to its constructor as a parameter. The Dependency Injection container handles the injection.
These are the views used in the WPF Quickstart:

EmployeeView (EmployeeData module): The following classes are required to complete the view logic:

Employee class. This is the view model, it is similar to the one used in the original WPF QuickStart but takes advantage of the C# 3.5 features.

public class Employee
{
    public int Id { set; get; }
    public string Name { set; get; }
    public string Position { set; get; }
    public int Age { set; get; }
    public DateTime EmployedOn { set; get; }
}

IEmployeeView interface

public interface IEmployeeView
{
    Employee Model { get; set; }
}

EmployeePresenter class

public class EmployeePresenter
{
    private EmployeeService _employeeService;
 
    public EmployeePresenter(IEmployeeView view, EmployeeService employeeService, IEventAggregator eventAggregator)
    {
        this.View = view;
        this._employeeService = employeeService;
 
        eventAggregator.GetEvent<ShowEmployeeEvent>()
           .Subscribe(SetSelectedEmployee, ThreadOption.UIThread, true);
    }
 
    public void SetSelectedEmployee(int index)
    {
        Employee employee = _employeeService.GetEmployee(index);
        View.Model = employee;
    }
 
    public IEmployeeView View { get; set; }
}

When the presenter is created, the container resolves its dependencies (the employee view, the employee service and the event aggregator). The presenter subscribes its SetSelectedEmployee method as a callback for the ShowEmployeeEvent event.

EmployeeView WPF User Control. The following code shows the code behind and the XAML file.

public partial class EmployeeView : UserControl, IEmployeeView
{
    public EmployeeView()
    {
        InitializeComponent();
    }
 
    public Employee Model
    {
        get { return this.DataContext as Employee; }
        set { this.DataContext = value; }
    }
}

<UserControl x:Class="EmployeeData.Views.EmployeeView"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:EmployeeData">
    <GroupBox Header="Employee Information">
        <Grid DataContext="{Binding}">
            <Grid.ColumnDefinitions>
                <ColumnDefinition></ColumnDefinition>
                <ColumnDefinition Width="5"></ColumnDefinition>
            </Grid.ColumnDefinitions>
            <Grid.RowDefinitions>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
            </Grid.RowDefinitions>
            <TextBlock Text="Name:" Grid.Column="0" Grid.Row="0"></TextBlock>
            <TextBlock Text="Position:" Grid.Column="0" Grid.Row="2"></TextBlock>
            <TextBlock Text="Age:" Grid.Column="0" Grid.Row="4"></TextBlock>
            <TextBlock Text="Employed On:" Grid.Column="0" Grid.Row="6"></TextBlock>
 
            <TextBox Text="{Binding Path=Name}" Grid.Column="0" Grid.Row="1"></TextBox>
            <TextBox Text="{Binding Path=Position}" Grid.Column="0" Grid.Row="3"></TextBox>
            <TextBox Text="{Binding Path=Age}" Grid.Column="0" Grid.Row="5"></TextBox>
            <TextBox Text="{Binding Path=EmployedOn}" Grid.Column="0" Grid.Row="7"></TextBox>
        </Grid>
    </GroupBox>
</UserControl>

The Figure 4 shows the final design of the view.

Figure 4
OrgCharView view

OrgChartView (OrganizationChart module): The following classes are required to complete the view logic:

IOrgChartView interface: Exposes the PositionSelected event to communicate the view with the presenter (since the view does not have a reference to its presenter).

public interface IOrgChartView
{
    event EventHandler<DataEventArgs<XmlElement>> PositionSelected;
    XmlDocument Model { get; set; }
}

OrgChartPresenter class: The presenter raises the ShowEmployeeEvent event when a position is selected in the view.

public class OrgChartPresenter
{
    private readonly IEventAggregator _eventAggregator;
 
    public OrgChartPresenter(IOrgChartView view, IEventAggregator eventAggregator)
    {
        this.View = view;
        this._eventAggregator = eventAggregator;
 
        this.View.PositionSelected += delegate(object sender, DataEventArgs<XmlElement> args)
          {
              if (_eventAggregator != null)
              {
                  int selectedEmployeeId = Int32.Parse(args.Value.Attributes["ID"].Value, CultureInfo.InvariantCulture);
 
                  _eventAggregator.GetEvent<ShowEmployeeEvent>()
                                           .Publish(selectedEmployeeId);
              }
          };
 
        XmlDocument chart = new XmlDocument();
        chart.Load(@"OrganizationChart.xml");
        View.Model = chart;
    }
 
    public IOrgChartView View { get; set; }
}

OrgChartView WPF User Control. When a user selects a position in the chart, the view raises the PositionSelected event. The following code shows the view´s code behind.

Note: The XAML code is not shown here for simplicity purposes. The code is the same as the one used in the original WPF Quickstart.

public partial class OrgChartView : UserControl, IOrgChartView
{
    public OrgChartView()
    {
        InitializeComponent();
    }
 
    public static readonly DependencyProperty OrgChartDataSourceProperty =
        DependencyProperty.Register("OrgChartDataSource", typeof(XmlDocument), typeof(OrgChartView), new FrameworkPropertyMetadata(null, new PropertyChangedCallback(OnValueChanged)));
 
    private static void OnValueChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
    {
        OrgChartView control = (OrgChartView)obj;
        XmlDataProvider provider = (XmlDataProvider)control.Resources["xdpOrgChart"];
        provider.Document = (XmlDocument)args.NewValue;
    }
 
    void SelectionChanged(object sender, RoutedEventArgs e)
    {
        XmlElement element = ((XmlElement)((TreeView)e.Source).SelectedItem);
        PositionSelected(this, new DataEventArgs<XmlElement>(element));
    }
 
    public XmlDocument Model
    {
        get { return (XmlDocument)GetValue(OrgChartDataSourceProperty); }
        set { SetValue(OrgChartDataSourceProperty, value); }
    }
 
    public event EventHandler<DataEventArgs<XmlElement>> PositionSelected = delegate { };
}

The Figure 5 shows the final design of the view (copied from the WPF Quickstart source code).

Figure 5
OrgCharView view

Checking the Results

Build and run the final solution by pressing F5. You will see both views from the EmployeeView and OrgChartView views loaded in the Shell:

Figure 6
Regenerated Quickstart running

If you click in a different block in the organization chart of the left view, you will see the corresponding employee information populated in the right view. This is accomplished with the EventAggregator service and the ShowEmployeeEvent event.

Updated Wiki: WPFQuickstartRegeneratedWithCAL

mconverti — Mon, 08 Sep 2008 13:53:16 GMT

Download pdf version of this document

Regenerating the WPF/SC-SF Quickstart with the Composite Application Library

Purpose
Prerequisites
Application Structure
Creating the initial solution

Preparing the Shell

Creating Modules
Creating Views
Checking the Results

Purpose

Prerequisites

This topic requires you to have the following Composite Application Library and Unity Application Block assemblies:

Microsoft.Practices.Composite.dll
Microsoft.Practices.Composite.Wpf.dll
Microsoft.Practices.Composite.UnityExtensions.dll
Microsoft.Practices.Unity.dll
Microsoft.Practices.ObjectBuilder2.dll

The Composite Application Library ships as source code, which means you must compile it to get the Composite Application Library assemblies.

Application Structure

Both the Composite Application Library and Composite UI Application Block applications have similar solution structure with the following components:

An startup project that contains the shell view that defines the layout
Modules that add views, services, and other functionalities
[Optionally] Infrastructure projects to share common artifacts and constants definitions.

Creating the initial solution

To be able to use the features of the Composite Application Library, you will need to create a pure WPF Application. To do this, follow these steps:

In Visual Studio, create a new WPF application named WPFQuickstartwithCAL.
Add the Common and Modules solution folders to the WPFQuickstartwithCAL solution.
Create a new Class Library project in the Common solution folder called WPFQuickstartwithCAL.Infrastructure.

Note: In this project you will place common components like constants and events definitions. This is just a good practice but it is not required.

Add the Constants and Events folders to the WPFQuickstartwithCAL.Infrastructure project.
Add the RegionNames class to the Constants folder and put there the definition of the following constants:

public const string RightRegion = "RightRegion";
public const string LeftRegion = "LeftRegion";

Add the ShowEmployeeEvent class to the Events folder with the following event definition:

public class ShowEmployeeEvent : CompositeWpfEvent<int>
{
}

Note: All the modules of the final solution have a reference to the WPFQuickstartwithCAL.Infrastructure project.

Preparing the Shell

The application starting point is a WPF Application project which contains a Shell, a Bootstrapper class and a App.xaml file. The following is a description of these artifacts:

Shell: A Composite WPF application should contain a place to host different UI components that exposes a way for itself to be populated by others. The following is the Shell used in this solution:

Bootstrapper class: This class inherits from UnityBootstrapper and is in charge of initializing the application. The Bootstrapper is responsible for:

Initialize the container (UnityBootstrapper base class uses the Unity container).
Register core services, like the RegionManager (it is used to get regions) and the EventAggregator (it is used to implement event brokering).
Register adapters for the region that the application uses.
Create and shows the shell.
Load the modules.

internal class Bootstrapper : UnityBootstrapper
{
    protected override IModuleEnumerator GetModuleEnumerator()
    {
        return new StaticModuleEnumerator()
            .AddModule(typeof(EmployeeDataModule))
            .AddModule(typeof(OrganizationChartModule));
    }
 
    protected override DependencyObject CreateShell()
    {
        Shell shell = new Shell();
        shell.Show();
 
        return shell;
    }
}

App.xaml file: The OnStartup method of the App class is overridden to create and initialize the Bootstrapper class.

protected override void OnStartup(StartupEventArgs e)
{
    base.OnStartup(e);
 
    Bootstrapper bootstrapper = new Bootstrapper();
    bootstrapper.Run();
}

Creating Modules

WPFQuickstartwithCAL.EmployeeData: In this module are placed the view that shows information about an employee (which is shown in the Right region of the Shell) and a service that retrieves data about employees. The following code shows the implementation of the EmployeeDataModule class.

public class EmployeeDataModule : IModule
{
    private IUnityContainer container;
    private IRegionManager regionManager;
 
    public EmployeeDataModule(IUnityContainer container, IRegionManager regionManager)
    {
        this.container = container;
        this.regionManager = regionManager;
    }
 
    public void Initialize()
    {
        this.RegisterViewsAndServices();
 
        EmployeePresenter presenter = this.container.Resolve<EmployeePresenter>();
 
        IRegion mainRegion = this.regionManager.Regions[RegionNames.RightRegion];
        mainRegion.Add(presenter.View);
    }
 
    protected void RegisterViewsAndServices()
    {
        this.container.RegisterType<IEmployeeView, EmployeeView>();
    }
}

WPFQuickstartwithCAL.OrganizationChart: In this module are placed the view that shows the organization chart. The view is showed in the Left region of the Shell. The following code shows the implementation of the OrganizationChartModule class.

public class OrganizationChartModule : IModule
{
    private IUnityContainer container;
    private IRegionManager regionManager;
 
    public OrganizationChartModule(IUnityContainer container, IRegionManager regionManager)
    {
        this.container = container;
        this.regionManager = regionManager;
    }
 
    public void Initialize()
    {
        this.RegisterViewsAndServices();
 
        OrgChartPresenter presenter = this.container.Resolve<OrgChartPresenter>();
 
        IRegion mainRegion = this.regionManager.Regions[RegionNames.LeftRegion];
        mainRegion.Add(presenter.View);
    }
 
    protected void RegisterViewsAndServices()
    {
        this.container.RegisterType<IOrgChartView, OrgChartView>();
    }
}

The Figure 3 shows the structure of the two modules in the solution explorer.

Figure 3
Modules structure

Creating Views

EmployeeView (EmployeeData module): The following classes are required to complete the view logic:

Employee class. This is the view model, it is similar to the one used in the original WPF QuickStart but takes advantage of the C# 3.5 features.

public class Employee
{
    public int Id { set; get; }
    public string Name { set; get; }
    public string Position { set; get; }
    public int Age { set; get; }
    public DateTime EmployedOn { set; get; }
}

IEmployeeView interface

public interface IEmployeeView
{
    Employee Model { get; set; }
}

EmployeePresenter class

public class EmployeePresenter
{
    private EmployeeService _employeeService;
 
    public EmployeePresenter(IEmployeeView view, EmployeeService employeeService, IEventAggregator eventAggregator)
    {
        this.View = view;
        this._employeeService = employeeService;
 
        eventAggregator.GetEvent<ShowEmployeeEvent>()
           .Subscribe(SetSelectedEmployee, ThreadOption.UIThread, true);
    }
 
    public void SetSelectedEmployee(int index)
    {
        Employee employee = _employeeService.GetEmployee(index);
        View.Model = employee;
    }
 
    public IEmployeeView View { get; set; }
}

EmployeeView WPF User Control. The following code shows the code behind and the XAML file.

public partial class EmployeeView : UserControl, IEmployeeView
{
    public EmployeeView()
    {
        InitializeComponent();
    }
 
    public Employee Model
    {
        get { return this.DataContext as Employee; }
        set { this.DataContext = value; }
    }
}

<UserControl x:Class="EmployeeData.Views.EmployeeView"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:EmployeeData">
    <GroupBox Header="Employee Information">
        <Grid DataContext="{Binding}">
            <Grid.ColumnDefinitions>
                <ColumnDefinition></ColumnDefinition>
                <ColumnDefinition Width="5"></ColumnDefinition>
            </Grid.ColumnDefinitions>
            <Grid.RowDefinitions>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
            </Grid.RowDefinitions>
            <TextBlock Text="Name:" Grid.Column="0" Grid.Row="0"></TextBlock>
            <TextBlock Text="Position:" Grid.Column="0" Grid.Row="2"></TextBlock>
            <TextBlock Text="Age:" Grid.Column="0" Grid.Row="4"></TextBlock>
            <TextBlock Text="Employed On:" Grid.Column="0" Grid.Row="6"></TextBlock>
 
            <TextBox Text="{Binding Path=Name}" Grid.Column="0" Grid.Row="1"></TextBox>
            <TextBox Text="{Binding Path=Position}" Grid.Column="0" Grid.Row="3"></TextBox>
            <TextBox Text="{Binding Path=Age}" Grid.Column="0" Grid.Row="5"></TextBox>
            <TextBox Text="{Binding Path=EmployedOn}" Grid.Column="0" Grid.Row="7"></TextBox>
        </Grid>
    </GroupBox>
</UserControl>

The Figure 4 shows the final design of the view.

Figure 4
OrgCharView view

OrgChartView (OrganizationChart module): The following classes are required to complete the view logic:

IOrgChartView interface: Exposes the PositionSelected event to communicate the view with the presenter (since the view does not have a reference to its presenter).

public interface IOrgChartView
{
    event EventHandler<DataEventArgs<XmlElement>> PositionSelected;
    XmlDocument Model { get; set; }
}

OrgChartPresenter class: The presenter raises the ShowEmployeeEvent event when a position is selected in the view.

public class OrgChartPresenter
{
    private readonly IEventAggregator _eventAggregator;
 
    public OrgChartPresenter(IOrgChartView view, IEventAggregator eventAggregator)
    {
        this.View = view;
        this._eventAggregator = eventAggregator;
 
        this.View.PositionSelected += delegate(object sender, DataEventArgs<XmlElement> args)
          {
              if (_eventAggregator != null)
              {
                  int selectedEmployeeId = Int32.Parse(args.Value.Attributes["ID"].Value, CultureInfo.InvariantCulture);
 
                  _eventAggregator.GetEvent<ShowEmployeeEvent>()
                                           .Publish(selectedEmployeeId);
              }
          };
 
        XmlDocument chart = new XmlDocument();
        chart.Load(@"OrganizationChart.xml");
        View.Model = chart;
    }
 
    public IOrgChartView View { get; set; }
}

OrgChartView WPF User Control. When a user selects a position in the chart, the view raises the PositionSelected event. The following code shows the view´s code behind.

Note: The XAML code is not shown here for simplicity purposes. The code is the same as the one used in the original WPF Quickstart.

public partial class OrgChartView : UserControl, IOrgChartView
{
    public OrgChartView()
    {
        InitializeComponent();
    }
 
    public static readonly DependencyProperty OrgChartDataSourceProperty =
        DependencyProperty.Register("OrgChartDataSource", typeof(XmlDocument), typeof(OrgChartView), new FrameworkPropertyMetadata(null, new PropertyChangedCallback(OnValueChanged)));
 
    private static void OnValueChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
    {
        OrgChartView control = (OrgChartView)obj;
        XmlDataProvider provider = (XmlDataProvider)control.Resources["xdpOrgChart"];
        provider.Document = (XmlDocument)args.NewValue;
    }
 
    void SelectionChanged(object sender, RoutedEventArgs e)
    {
        XmlElement element = ((XmlElement)((TreeView)e.Source).SelectedItem);
        PositionSelected(this, new DataEventArgs<XmlElement>(element));
    }
 
    public XmlDocument Model
    {
        get { return (XmlDocument)GetValue(OrgChartDataSourceProperty); }
        set { SetValue(OrgChartDataSourceProperty, value); }
    }
 
    public event EventHandler<DataEventArgs<XmlElement>> PositionSelected = delegate { };
}

The Figure 5 shows the final design of the view (copied from the WPF Quickstart source code).

Figure 5
OrgCharView view

Checking the Results

Updated Wiki: WPFQuickstartRegeneratedWithCAL

mconverti — Sun, 07 Sep 2008 21:53:32 GMT

Regenerating the WPF/SC-SF Quickstart with the Composite Application Library

Purpose
Prerequisites
Application Structure
Creating the initial solution

Preparing the Shell

Creating Modules
Creating Views
Checking the Results

Purpose

Prerequisites

This topic requires you to have the following Composite Application Library and Unity Application Block assemblies:

Microsoft.Practices.Composite.dll
Microsoft.Practices.Composite.Wpf.dll
Microsoft.Practices.Composite.UnityExtensions.dll
Microsoft.Practices.Unity.dll
Microsoft.Practices.ObjectBuilder2.dll

The Composite Application Library ships as source code, which means you must compile it to get the Composite Application Library assemblies.

Application Structure

Both the Composite Application Library and Composite UI Application Block applications have similar solution structure with the following components:

An startup project that contains the shell view that defines the layout
Modules that add views, services, and other functionalities
[Optionally] Infrastructure projects to share common artifacts and constants definitions.

Creating the initial solution

To be able to use the features of the Composite Application Library, you will need to create a pure WPF Application. To do this, follow these steps:

In Visual Studio, create a new WPF application named WPFQuickstartwithCAL.
Add the Common and Modules solution folders to the WPFQuickstartwithCAL solution.
Create a new Class Library project in the Common solution folder called WPFQuickstartwithCAL.Infrastructure.

Note: In this project you will place common components like constants and events definitions. This is just a good practice but it is not required.

Add the Constants and Events folders to the WPFQuickstartwithCAL.Infrastructure project.
Add the RegionNames class to the Constants folder and put there the definition of the following constants:

public const string RightRegion = "RightRegion";
public const string LeftRegion = "LeftRegion";

Add the ShowEmployeeEvent class to the Events folder with the following event definition:

public class ShowEmployeeEvent : CompositeWpfEvent<int>
{
}

Note: All the modules of the final solution have a reference to the WPFQuickstartwithCAL.Infrastructure project.

Preparing the Shell

The application starting point is a WPF Application project which contains a Shell, a Bootstrapper class and a App.xaml file. The following is a description of these artifacts:

Shell: A Composite WPF application should contain a place to host different UI components that exposes a way for itself to be populated by others. The following is the Shell used in this solution:

Bootstrapper class: This class inherits from UnityBootstrapper and is in charge of initializing the application. The Bootstrapper is responsible for:

Initialize the container (UnityBootstrapper base class uses the Unity container).
Register core services, like the RegionManager (it is used to get regions) and the EventAggregator (it is used to implement event brokering).
Register adapters for the region that the application uses.
Create and shows the shell.
Load the modules.

internal class Bootstrapper : UnityBootstrapper
{
    protected override IModuleEnumerator GetModuleEnumerator()
    {
        return new StaticModuleEnumerator()
            .AddModule(typeof(EmployeeDataModule))
            .AddModule(typeof(OrganizationChartModule));
    }
 
    protected override DependencyObject CreateShell()
    {
        Shell shell = new Shell();
        shell.Show();
 
        return shell;
    }
}

App.xaml file: The OnStartup method of the App class is overridden to create and initialize the Bootstrapper class.

protected override void OnStartup(StartupEventArgs e)
{
    base.OnStartup(e);
 
    Bootstrapper bootstrapper = new Bootstrapper();
    bootstrapper.Run();
}

Creating Modules

WPFQuickstartwithCAL.EmployeeData: In this module are placed the view that shows information about an employee (which is shown in the Right region of the Shell) and a service that retrieves data about employees. The following code shows the implementation of the EmployeeDataModule class.

public class EmployeeDataModule : IModule
{
    private IUnityContainer container;
    private IRegionManager regionManager;
 
    public EmployeeDataModule(IUnityContainer container, IRegionManager regionManager)
    {
        this.container = container;
        this.regionManager = regionManager;
    }
 
    public void Initialize()
    {
        this.RegisterViewsAndServices();
 
        EmployeePresenter presenter = this.container.Resolve<EmployeePresenter>();
 
        IRegion mainRegion = this.regionManager.Regions[RegionNames.RightRegion];
        mainRegion.Add(presenter.View);
    }
 
    protected void RegisterViewsAndServices()
    {
        this.container.RegisterType<IEmployeeView, EmployeeView>();
    }
}

WPFQuickstartwithCAL.OrganizationChart: In this module are placed the view that shows the organization chart. The view is showed in the Left region of the Shell. The following code shows the implementation of the OrganizationChartModule class.

public class OrganizationChartModule : IModule
{
    private IUnityContainer container;
    private IRegionManager regionManager;
 
    public OrganizationChartModule(IUnityContainer container, IRegionManager regionManager)
    {
        this.container = container;
        this.regionManager = regionManager;
    }
 
    public void Initialize()
    {
        this.RegisterViewsAndServices();
 
        OrgChartPresenter presenter = this.container.Resolve<OrgChartPresenter>();
 
        IRegion mainRegion = this.regionManager.Regions[RegionNames.LeftRegion];
        mainRegion.Add(presenter.View);
    }
 
    protected void RegisterViewsAndServices()
    {
        this.container.RegisterType<IOrgChartView, OrgChartView>();
    }
}

The Figure 3 shows the structure of the two modules in the solution explorer.

Figure 3
Modules structure

Creating Views

EmployeeView (EmployeeData module): The following classes are required to complete the view logic:

Employee class. This is the view model, it is similar to the one used in the original WPF QuickStart but takes advantage of the C# 3.5 features.

public class Employee
{
    public int Id { set; get; }
    public string Name { set; get; }
    public string Position { set; get; }
    public int Age { set; get; }
    public DateTime EmployedOn { set; get; }
}

IEmployeeView interface

public interface IEmployeeView
{
    Employee Model { get; set; }
}

EmployeePresenter class

public class EmployeePresenter
{
    private EmployeeService _employeeService;
 
    public EmployeePresenter(IEmployeeView view, EmployeeService employeeService, IEventAggregator eventAggregator)
    {
        this.View = view;
        this._employeeService = employeeService;
 
        eventAggregator.GetEvent<ShowEmployeeEvent>()
           .Subscribe(SetSelectedEmployee, ThreadOption.UIThread, true);
    }
 
    public void SetSelectedEmployee(int index)
    {
        Employee employee = _employeeService.GetEmployee(index);
        View.Model = employee;
    }
 
    public IEmployeeView View { get; set; }
}

EmployeeView WPF User Control. The following code shows the code behind and the XAML file.

public partial class EmployeeView : UserControl, IEmployeeView
{
    public EmployeeView()
    {
        InitializeComponent();
    }
 
    public Employee Model
    {
        get { return this.DataContext as Employee; }
        set { this.DataContext = value; }
    }
}

<UserControl x:Class="EmployeeData.Views.EmployeeView"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:EmployeeData">
    <GroupBox Header="Employee Information">
        <Grid DataContext="{Binding}">
            <Grid.ColumnDefinitions>
                <ColumnDefinition></ColumnDefinition>
                <ColumnDefinition Width="5"></ColumnDefinition>
            </Grid.ColumnDefinitions>
            <Grid.RowDefinitions>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
            </Grid.RowDefinitions>
            <TextBlock Text="Name:" Grid.Column="0" Grid.Row="0"></TextBlock>
            <TextBlock Text="Position:" Grid.Column="0" Grid.Row="2"></TextBlock>
            <TextBlock Text="Age:" Grid.Column="0" Grid.Row="4"></TextBlock>
            <TextBlock Text="Employed On:" Grid.Column="0" Grid.Row="6"></TextBlock>
 
            <TextBox Text="{Binding Path=Name}" Grid.Column="0" Grid.Row="1"></TextBox>
            <TextBox Text="{Binding Path=Position}" Grid.Column="0" Grid.Row="3"></TextBox>
            <TextBox Text="{Binding Path=Age}" Grid.Column="0" Grid.Row="5"></TextBox>
            <TextBox Text="{Binding Path=EmployedOn}" Grid.Column="0" Grid.Row="7"></TextBox>
        </Grid>
    </GroupBox>
</UserControl>

The Figure 4 shows the final design of the view.

Figure 4
OrgCharView view

OrgChartView (OrganizationChart module): The following classes are required to complete the view logic:

IOrgChartView interface: Exposes the PositionSelected event to communicate the view with the presenter (since the view does not have a reference to its presenter).

public interface IOrgChartView
{
    event EventHandler<DataEventArgs<XmlElement>> PositionSelected;
    XmlDocument Model { get; set; }
}

OrgChartPresenter class: The presenter raises the ShowEmployeeEvent event when a position is selected in the view.

public class OrgChartPresenter
{
    private readonly IEventAggregator _eventAggregator;
 
    public OrgChartPresenter(IOrgChartView view, IEventAggregator eventAggregator)
    {
        this.View = view;
        this._eventAggregator = eventAggregator;
 
        this.View.PositionSelected += delegate(object sender, DataEventArgs<XmlElement> args)
          {
              if (_eventAggregator != null)
              {
                  int selectedEmployeeId = Int32.Parse(args.Value.Attributes["ID"].Value, CultureInfo.InvariantCulture);
 
                  _eventAggregator.GetEvent<ShowEmployeeEvent>()
                                           .Publish(selectedEmployeeId);
              }
          };
 
        XmlDocument chart = new XmlDocument();
        chart.Load(@"OrganizationChart.xml");
        View.Model = chart;
    }
 
    public IOrgChartView View { get; set; }
}

OrgChartView WPF User Control. When a user selects a position in the chart, the view raises the PositionSelected event. The following code shows the view´s code behind.

Note: The XAML code is not shown here for simplicity purposes. The code is the same as the one used in the original WPF Quickstart.

public partial class OrgChartView : UserControl, IOrgChartView
{
    public OrgChartView()
    {
        InitializeComponent();
    }
 
    public static readonly DependencyProperty OrgChartDataSourceProperty =
        DependencyProperty.Register("OrgChartDataSource", typeof(XmlDocument), typeof(OrgChartView), new FrameworkPropertyMetadata(null, new PropertyChangedCallback(OnValueChanged)));
 
    private static void OnValueChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
    {
        OrgChartView control = (OrgChartView)obj;
        XmlDataProvider provider = (XmlDataProvider)control.Resources["xdpOrgChart"];
        provider.Document = (XmlDocument)args.NewValue;
    }
 
    void SelectionChanged(object sender, RoutedEventArgs e)
    {
        XmlElement element = ((XmlElement)((TreeView)e.Source).SelectedItem);
        PositionSelected(this, new DataEventArgs<XmlElement>(element));
    }
 
    public XmlDocument Model
    {
        get { return (XmlDocument)GetValue(OrgChartDataSourceProperty); }
        set { SetValue(OrgChartDataSourceProperty, value); }
    }
 
    public event EventHandler<DataEventArgs<XmlElement>> PositionSelected = delegate { };
}

The Figure 5 shows the final design of the view (copied from the WPF Quickstart source code).

Figure 5
OrgCharView view

Checking the Results

Updated Wiki: Home

mconverti — Sun, 07 Sep 2008 21:49:50 GMT

Welcome to the Composite WPF Contrib project

Composite WPF Contrib is a community-developed library of extensions to the patterns & practices Composite WPF project.

If you are building custom tools and extensions and want to share them then Composite WPF Contrib will get it out to the masses.
If you've got a great idea for new extensions Composite WPF contrib is the place to find developers ready, willing, and able to make it happen.
If you use Composite WPF within your org, then Composite WPF Contrib is the place to find tools and extensions to add to your arsenal.
If you want to connect with others who are pushing the bar on Prism development, then Prism Contrib is the place to be.

Prism contrib is about YOU. With your help we can make it a vibrant resource for WPF Composite developers world-wide.

News

(2008-09-07) New Sample

WPF Quickstart shipped with the Smart Client Software Factory regenerated using the Composite Application Guidance for WPF.

(2008-09-05) New Extensions

DialogWorkspace Show any view as a dialog in your application. Sample is included.

(2008-08-11) New Sample

Sample application that demonstrate how to use the Disconnected Service Agent Application Block with CompositeWPF

(2008-07-31) New Extensions

TabGroupPaneRegionAdapter. Infragistics TabGroupPane Region Adapter for CompositeWPF

(2008-07-25) New Extensions

ExtendedModuleLoaderService. Extended module loader service with support to install modules on demand using windows installer

(2008-07-21) New Extensions

OutlookBar. OutlookBar control and region adapter for CompositeWPF

(2008-07-17) New Extensions

Module Status Service. The Module Status Service can be used to retrieve information about what modules are loaded

(2008-07-11) New Extensions

CompositeModuleEnumerator. The CompositeModuleEnumerator makes it possible to combine several module enumerator instances into one module enumerator.
ToolBarPanelRegionAdapter. This adapter adapts control of type System.Windows.Controls.Primitives.ToolBarPanel and derived classes.

(2008-07-08) New Visual Studio Templates. The goal of these templates is to help users start with the Composite WPF project.

What's in Prism Contrib?

PrismAG - Composite WPF for Silverlight
OutlookBar - OutlookBar control and region adapter for CompositeWPF
CompositeModuleEnumerator - Composite Module Enumerator
Module Status Service - A service that can be used to retrieve information about what modules are loaded
Extended Module Service - An extended module loader service with support to install modules on demand using windows installer
Visual Studio Templates
Composite WPF Extensions - Add-on commands, services, regions, etc to aid you in your Composite WPF development
Infragistics Extensions - Infragistics Extensions for CompositeWPF
Samples

See the Documentation index for information on how to use each of these extensions and components.

Contributing to Composite WPF Contrib

Would you like to join as a developer of the Composite WPF Contrib project to share your own extensions or improve the existing codebase? Great! Here is what you need to know

Other p&p Contrib Projects

Updated Wiki: Documentation

mconverti — Sun, 07 Sep 2008 20:42:44 GMT

Documentation

Updated Wiki: WPFQuickstartRegeneratedWithCAL

mconverti — Sun, 07 Sep 2008 20:40:34 GMT

Regenerating the WPF/SC-SF Quickstart with the Composite Application Library

Purpose
Prerequisites
Application Structure
Creating the initial solution

Preparing the Shell

Creating Modules
Creating Views
Checking the Results

Purpose

Prerequisites

This topic requires you to have the following Composite Application Library and Unity Application Block assemblies:

Microsoft.Practices.Composite.dll
Microsoft.Practices.Composite.Wpf.dll
Microsoft.Practices.Composite.UnityExtensions.dll
Microsoft.Practices.Unity.dll
Microsoft.Practices.ObjectBuilder2.dll

The Composite Application Library ships as source code, which means you must compile it to get the Composite Application Library assemblies.

Application Structure

Both the Composite Application Library and Composite UI Application Block applications have similar solution structure with the following components:

An startup project that contains the shell view that defines the layout
Modules that add views, services, and other functionalities
[Optionally] Infrastructure projects to share common artifacts and constants definitions.

Creating the initial solution

To be able to use the features of the Composite Application Library, you will need to create a pure WPF Application. To do this, follow these steps:

In Visual Studio, create a new WPF application named WPFQuickstartwithCAL.
Add the Common and Modules solution folders to the WPFQuickstartwithCAL solution.
Create a new Class Library project in the Common solution folder called WPFQuickstartwithCAL.Infrastructure.

Note: In this project you will place common components like constants and events definitions. This is just a good practice but it is not required.

Add the Constants and Events folders to the WPFQuickstartwithCAL.Infrastructure project.
Add the RegionNames class to the Constants folder and put there the definition of the following constants:

public const string RightRegion = "RightRegion";
public const string LeftRegion = "LeftRegion";

Add the ShowEmployeeEvent class to the Events folder with the following event definition:

public class ShowEmployeeEvent : CompositeWpfEvent<int>
{
}

Note: All the modules of the final solution have a reference to the WPFQuickstartwithCAL.Infrastructure project.

Preparing the Shell

The application starting point is a WPF Application project which contains a Shell, a Bootstrapper class and a App.xaml file. The following is a description of these artifacts:

Shell: A Composite WPF application should contain a place to host different UI components that exposes a way for itself to be populated by others. The following is the Shell used in this solution:

Bootstrapper class: This class inherits from UnityBootstrapper and is in charge of initializing the application. The Bootstrapper is responsible for:

Initialize the container (UnityBootstrapper base class uses the Unity container).
Register core services, like the RegionManager (it is used to get regions) and the EventAggregator (it is used to implement event brokering).
Register adapters for the region that the application uses.
Create and shows the shell.
Load the modules.

internal class Bootstrapper : UnityBootstrapper
{
    protected override IModuleEnumerator GetModuleEnumerator()
    {
        return new StaticModuleEnumerator()
            .AddModule(typeof(EmployeeDataModule))
            .AddModule(typeof(OrganizationChartModule));
    }
 
    protected override DependencyObject CreateShell()
    {
        Shell shell = new Shell();
        shell.Show();
 
        return shell;
    }
}

App.xaml file: The OnStartup method of the App class is overridden to create and initialize the Bootstrapper class.

protected override void OnStartup(StartupEventArgs e)
{
    base.OnStartup(e);
 
    Bootstrapper bootstrapper = new Bootstrapper();
    bootstrapper.Run();
}

Creating Modules

WPFQuickstartwithCAL.EmployeeData: In this module are placed the view that shows information about an employee (which is shown in the Right region of the Shell) and a service that retrieves data about employees. The following code shows the implementation of the EmployeeDataModule class.

public class EmployeeDataModule : IModule
{
    private IUnityContainer container;
    private IRegionManager regionManager;
 
    public EmployeeDataModule(IUnityContainer container, IRegionManager regionManager)
    {
        this.container = container;
        this.regionManager = regionManager;
    }
 
    public void Initialize()
    {
        this.RegisterViewsAndServices();
 
        EmployeePresenter presenter = this.container.Resolve<EmployeePresenter>();
 
        IRegion mainRegion = this.regionManager.Regions[RegionNames.RightRegion];
        mainRegion.Add(presenter.View);
    }
 
    protected void RegisterViewsAndServices()
    {
        this.container.RegisterType<IEmployeeView, EmployeeView>();
    }
}

WPFQuickstartwithCAL.OrganizationChart: In this module are placed the view that shows the organization chart. The view is showed in the Left region of the Shell. The following code shows the implementation of the OrganizationChartModule class.

public class OrganizationChartModule : IModule
{
    private IUnityContainer container;
    private IRegionManager regionManager;
 
    public OrganizationChartModule(IUnityContainer container, IRegionManager regionManager)
    {
        this.container = container;
        this.regionManager = regionManager;
    }
 
    public void Initialize()
    {
        this.RegisterViewsAndServices();
 
        OrgChartPresenter presenter = this.container.Resolve<OrgChartPresenter>();
 
        IRegion mainRegion = this.regionManager.Regions[RegionNames.LeftRegion];
        mainRegion.Add(presenter.View);
    }
 
    protected void RegisterViewsAndServices()
    {
        this.container.RegisterType<IOrgChartView, OrgChartView>();
    }
}

The Figure 3 shows the structure of the two modules in the solution explorer.

Figure 3
Modules structure

Creating Views

EmployeeView (EmployeeData module): The following classes are required to complete the view logic:

Employee class. This is the view model, it is similar to the one used in the original WPF QuickStart but takes advantage of the C# 3.5 features.

public class Employee
{
    public int Id { set; get; }
    public string Name { set; get; }
    public string Position { set; get; }
    public int Age { set; get; }
    public DateTime EmployedOn { set; get; }
}

IEmployeeView interface

public interface IEmployeeView
{
    Employee Model { get; set; }
}

EmployeePresenter class

public class EmployeePresenter
{
    private EmployeeService _employeeService;
 
    public EmployeePresenter(IEmployeeView view, EmployeeService employeeService, IEventAggregator eventAggregator)
    {
        this.View = view;
        this._employeeService = employeeService;
 
        eventAggregator.GetEvent<ShowEmployeeEvent>()
           .Subscribe(SetSelectedEmployee, ThreadOption.UIThread, true);
    }
 
    public void SetSelectedEmployee(int index)
    {
        Employee employee = _employeeService.GetEmployee(index);
        View.Model = employee;
    }
 
    public IEmployeeView View { get; set; }
}

EmployeeView WPF User Control. The following code shows the code behind and the XAML file.

public partial class EmployeeView : UserControl, IEmployeeView
{
    public EmployeeView()
    {
        InitializeComponent();
    }
 
    public Employee Model
    {
        get { return this.DataContext as Employee; }
        set { this.DataContext = value; }
    }
}

<UserControl x:Class="EmployeeData.Views.EmployeeView"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:EmployeeData">
    <GroupBox Header="Employee Information">
        <Grid DataContext="{Binding}">
            <Grid.ColumnDefinitions>
                <ColumnDefinition></ColumnDefinition>
                <ColumnDefinition Width="5"></ColumnDefinition>
            </Grid.ColumnDefinitions>
            <Grid.RowDefinitions>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
            </Grid.RowDefinitions>
            <TextBlock Text="Name:" Grid.Column="0" Grid.Row="0"></TextBlock>
            <TextBlock Text="Position:" Grid.Column="0" Grid.Row="2"></TextBlock>
            <TextBlock Text="Age:" Grid.Column="0" Grid.Row="4"></TextBlock>
            <TextBlock Text="Employed On:" Grid.Column="0" Grid.Row="6"></TextBlock>
 
            <TextBox Text="{Binding Path=Name}" Grid.Column="0" Grid.Row="1"></TextBox>
            <TextBox Text="{Binding Path=Position}" Grid.Column="0" Grid.Row="3"></TextBox>
            <TextBox Text="{Binding Path=Age}" Grid.Column="0" Grid.Row="5"></TextBox>
            <TextBox Text="{Binding Path=EmployedOn}" Grid.Column="0" Grid.Row="7"></TextBox>
        </Grid>
    </GroupBox>
</UserControl>

The Figure 4 shows the final design of the view.

Figure 4
OrgCharView view

OrgChartView (OrganizationChart module): The following classes are required to complete the view logic:

IOrgChartView interface: Exposes the PositionSelected event to communicate the view with the presenter (since the view does not have a reference to its presenter).

public interface IOrgChartView
{
    event EventHandler<DataEventArgs<XmlElement>> PositionSelected;
    XmlDocument Model { get; set; }
}

OrgChartPresenter class: The presenter raises the ShowEmployeeEvent event when a position is selected in the view.

public class OrgChartPresenter
{
    private readonly IEventAggregator _eventAggregator;
 
    public OrgChartPresenter(IOrgChartView view, IEventAggregator eventAggregator)
    {
        this.View = view;
        this._eventAggregator = eventAggregator;
 
        this.View.PositionSelected += delegate(object sender, DataEventArgs<XmlElement> args)
          {
              if (_eventAggregator != null)
              {
                  int selectedEmployeeId = Int32.Parse(args.Value.Attributes["ID"].Value, CultureInfo.InvariantCulture);
 
                  _eventAggregator.GetEvent<ShowEmployeeEvent>()
                                           .Publish(selectedEmployeeId);
              }
          };
 
        XmlDocument chart = new XmlDocument();
        chart.Load(@"OrganizationChart.xml");
        View.Model = chart;
    }
 
    public IOrgChartView View { get; set; }
}

OrgChartView WPF User Control. When a user selects a position in the chart, the view raises the PositionSelected event. The following code shows the view´s code behind.

Note: The XAML code is not shown here for simplicity purposes. The code is the same as the one used in the original WPF Quickstart.

public partial class OrgChartView : UserControl, IOrgChartView
{
    public OrgChartView()
    {
        InitializeComponent();
    }
 
    public static readonly DependencyProperty OrgChartDataSourceProperty =
        DependencyProperty.Register("OrgChartDataSource", typeof(XmlDocument), typeof(OrgChartView), new FrameworkPropertyMetadata(null, new PropertyChangedCallback(OnValueChanged)));
 
    private static void OnValueChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
    {
        OrgChartView control = (OrgChartView)obj;
        XmlDataProvider provider = (XmlDataProvider)control.Resources["xdpOrgChart"];
        provider.Document = (XmlDocument)args.NewValue;
    }
 
    void SelectionChanged(object sender, RoutedEventArgs e)
    {
        XmlElement element = ((XmlElement)((TreeView)e.Source).SelectedItem);
        PositionSelected(this, new DataEventArgs<XmlElement>(element));
    }
 
    public XmlDocument Model
    {
        get { return (XmlDocument)GetValue(OrgChartDataSourceProperty); }
        set { SetValue(OrgChartDataSourceProperty, value); }
    }
 
    public event EventHandler<DataEventArgs<XmlElement>> PositionSelected = delegate { };
}

The Figure 5 shows the final design of the view (copied from the WPF Quickstart source code).

Figure 5
OrgCharView view

Checking the Results

Build and run the final solution by pressing F5. You will see both views from the EmployeeView and OrgChartView views loaded in the Shell:

Figure 6
Regenerated Quickstart running
If you click in a different block in the organization chart of the left view, you will see the corresponding employee information populated in the right view. This is accomplished with the EventAggregator service and the ShowEmployeeEvent event.

Updated Wiki: WPFQuickstartRegeneratedWithCAL

mconverti — Sun, 07 Sep 2008 20:38:55 GMT

Regenerating the WPF/SC-SF Quickstart with the Composite Application Library

Purpose
Prerequisites
Application Structure
Creating the initial solution

Preparing the Shell

Creating Modules
Creating Views
Checking the Results

Purpose

Prerequisites

This topic requires you to have the following Composite Application Library and Unity Application Block assemblies:

Microsoft.Practices.Composite.dll
Microsoft.Practices.Composite.Wpf.dll
Microsoft.Practices.Composite.UnityExtensions.dll
Microsoft.Practices.Unity.dll
Microsoft.Practices.ObjectBuilder2.dll

The Composite Application Library ships as source code, which means you must compile it to get the Composite Application Library assemblies.

Application Structure

Both the Composite Application Library and Composite UI Application Block applications have similar solution structure with the following components:

An startup project that contains the shell view that defines the layout
Modules that add views, services, and other functionalities
[Optionally] Infrastructure projects to share common artifacts and constants definitions.

Creating the initial solution

To be able to use the features of the Composite Application Library, you will need to create a pure WPF Application. To do this, follow these steps:

In Visual Studio, create a new WPF application named WPFQuickstartwithCAL.
Add the Common and Modules solution folders to the WPFQuickstartwithCAL solution.
Create a new Class Library project in the Common solution folder called WPFQuickstartwithCAL.Infrastructure.

Note: In this project you will place common components like constants and events definitions. This is just a good practice but it is not required.

Add the Constants and Events folders to the WPFQuickstartwithCAL.Infrastructure project.
Add the RegionNames class to the Constants folder and put there the definition of the following constants:

public const string RightRegion = "RightRegion";
public const string LeftRegion = "LeftRegion";

Add the ShowEmployeeEvent class to the Events folder with the following event definition:

public class ShowEmployeeEvent : CompositeWpfEvent<int>
{
}

Note: All the modules of the final solution have a reference to the WPFQuickstartwithCAL.Infrastructure project.

Preparing the Shell

The application starting point is a WPF Application project which contains a Shell, a Bootstrapper class and a App.xaml file. The following is a description of these artifacts:

Shell: A Composite WPF application should contain a place to host different UI components that exposes a way for itself to be populated by others. The following is the Shell used in this solution:

Bootstrapper class: This class inherits from UnityBootstrapper and is in charge of initializing the application. The Bootstrapper is responsible for:

Initialize the container (UnityBootstrapper base class uses the Unity container).
Register core services, like the RegionManager (it is used to get regions) and the EventAggregator (it is used to implement event brokering).
Register adapters for the region that the application uses.
Create and shows the shell.
Load the modules.

internal class Bootstrapper : UnityBootstrapper
{
    protected override IModuleEnumerator GetModuleEnumerator()
    {
        return new StaticModuleEnumerator()
            .AddModule(typeof(EmployeeDataModule))
            .AddModule(typeof(OrganizationChartModule));
    }
 
    protected override DependencyObject CreateShell()
    {
        Shell shell = new Shell();
        shell.Show();
 
        return shell;
    }
}

App.xaml file: The OnStartup method of the App class is overridden to create and initialize the Bootstrapper class.

protected override void OnStartup(StartupEventArgs e)
{
    base.OnStartup(e);
 
    Bootstrapper bootstrapper = new Bootstrapper();
    bootstrapper.Run();
}

Creating Modules

WPFQuickstartwithCAL.EmployeeData: In this module are placed the view that shows information about an employee (which is shown in the Right region of the Shell) and a service that retrieves data about employees. The following code shows the implementation of the EmployeeDataModule class.

public class EmployeeDataModule : IModule
{
    private IUnityContainer container;
    private IRegionManager regionManager;
 
    public EmployeeDataModule(IUnityContainer container, IRegionManager regionManager)
    {
        this.container = container;
        this.regionManager = regionManager;
    }
 
    public void Initialize()
    {
        this.RegisterViewsAndServices();
 
        EmployeePresenter presenter = this.container.Resolve<EmployeePresenter>();
 
        IRegion mainRegion = this.regionManager.Regions[RegionNames.RightRegion];
        mainRegion.Add(presenter.View);
    }
 
    protected void RegisterViewsAndServices()
    {
        this.container.RegisterType<IEmployeeView, EmployeeView>();
    }
}

WPFQuickstartwithCAL.OrganizationChart: In this module are placed the view that shows the organization chart. The view is showed in the Left region of the Shell. The following code shows the implementation of the OrganizationChartModule class.

public class OrganizationChartModule : IModule
{
    private IUnityContainer container;
    private IRegionManager regionManager;
 
    public OrganizationChartModule(IUnityContainer container, IRegionManager regionManager)
    {
        this.container = container;
        this.regionManager = regionManager;
    }
 
    public void Initialize()
    {
        this.RegisterViewsAndServices();
 
        OrgChartPresenter presenter = this.container.Resolve<OrgChartPresenter>();
 
        IRegion mainRegion = this.regionManager.Regions[RegionNames.LeftRegion];
        mainRegion.Add(presenter.View);
    }
 
    protected void RegisterViewsAndServices()
    {
        this.container.RegisterType<IOrgChartView, OrgChartView>();
    }
}

The Figure 3 shows the structure of the two modules in the solution explorer.

Figure 3
Modules structure

Creating Views

EmployeeView (EmployeeData module): The following classes are required to complete the view logic:

Employee class. This is the view model, it is similar to the one used in the original WPF QuickStart but takes advantage of the C# 3.5 features.

public class Employee
{
    public int Id { set; get; }
    public string Name { set; get; }
    public string Position { set; get; }
    public int Age { set; get; }
    public DateTime EmployedOn { set; get; }
}

IEmployeeView interface

public interface IEmployeeView
{
    Employee Model { get; set; }
}

EmployeePresenter class

public class EmployeePresenter
{
    private EmployeeService _employeeService;
 
    public EmployeePresenter(IEmployeeView view, EmployeeService employeeService, IEventAggregator eventAggregator)
    {
        this.View = view;
        this._employeeService = employeeService;
 
        eventAggregator.GetEvent<ShowEmployeeEvent>()
           .Subscribe(SetSelectedEmployee, ThreadOption.UIThread, true);
    }
 
    public void SetSelectedEmployee(int index)
    {
        Employee employee = _employeeService.GetEmployee(index);
        View.Model = employee;
    }
 
    public IEmployeeView View { get; set; }
}

EmployeeView WPF User Control. The following code shows the code behind and the XAML file.

public partial class EmployeeView : UserControl, IEmployeeView
{
    public EmployeeView()
    {
        InitializeComponent();
    }
 
    public Employee Model
    {
        get { return this.DataContext as Employee; }
        set { this.DataContext = value; }
    }
}

<UserControl x:Class="EmployeeData.Views.EmployeeView"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:EmployeeData">
    <GroupBox Header="Employee Information">
        <Grid DataContext="{Binding}">
            <Grid.ColumnDefinitions>
                <ColumnDefinition></ColumnDefinition>
                <ColumnDefinition Width="5"></ColumnDefinition>
            </Grid.ColumnDefinitions>
            <Grid.RowDefinitions>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
                <RowDefinition></RowDefinition>
            </Grid.RowDefinitions>
            <TextBlock Text="Name:" Grid.Column="0" Grid.Row="0"></TextBlock>
            <TextBlock Text="Position:" Grid.Column="0" Grid.Row="2"></TextBlock>
            <TextBlock Text="Age:" Grid.Column="0" Grid.Row="4"></TextBlock>
            <TextBlock Text="Employed On:" Grid.Column="0" Grid.Row="6"></TextBlock>
 
            <TextBox Text="{Binding Path=Name}" Grid.Column="0" Grid.Row="1"></TextBox>
            <TextBox Text="{Binding Path=Position}" Grid.Column="0" Grid.Row="3"></TextBox>
            <TextBox Text="{Binding Path=Age}" Grid.Column="0" Grid.Row="5"></TextBox>
            <TextBox Text="{Binding Path=EmployedOn}" Grid.Column="0" Grid.Row="7"></TextBox>
        </Grid>
    </GroupBox>
</UserControl>

The Figure 4 shows the final design of the view.

Figure 4
OrgCharView view

OrgChartView (OrganizationChart module): The following classes are required to complete the view logic:

IOrgChartView interface: Exposes the PositionSelected event to communicate the view with the presenter (since the view does not have a reference to its presenter).

public interface IOrgChartView
{
    event EventHandler<DataEventArgs<XmlElement>> PositionSelected;
    XmlDocument Model { get; set; }
}

OrgChartPresenter class: The presenter raises the ShowEmployeeEvent event when a position is selected in the view.

public class OrgChartPresenter
{
    private readonly IEventAggregator _eventAggregator;
 
    public OrgChartPresenter(IOrgChartView view, IEventAggregator eventAggregator)
    {
        this.View = view;
        this._eventAggregator = eventAggregator;
 
        this.View.PositionSelected += delegate(object sender, DataEventArgs<XmlElement> args)
          {
              if (_eventAggregator != null)
              {
                  int selectedEmployeeId = Int32.Parse(args.Value.Attributes["ID"].Value, CultureInfo.InvariantCulture);
 
                  _eventAggregator.GetEvent<ShowEmployeeEvent>()
                                           .Publish(selectedEmployeeId);
              }
          };
 
        XmlDocument chart = new XmlDocument();
        chart.Load(@"OrganizationChart.xml");
        View.Model = chart;
    }
 
    public IOrgChartView View { get; set; }
}

OrgChartView WPF User Control. When a user selects a position in the chart, the view raises the PositionSelected event. The following code shows the view´s code behind.

Note: The XAML code is not shown here for simplicity purposes. The code is the same as the one used in the original WPF Quickstart.

public partial class OrgChartView : UserControl, IOrgChartView
{
    public OrgChartView()
    {
        InitializeComponent();
    }
 
    public static readonly DependencyProperty OrgChartDataSourceProperty =
        DependencyProperty.Register("OrgChartDataSource", typeof(XmlDocument), typeof(OrgChartView), new FrameworkPropertyMetadata(null, new PropertyChangedCallback(OnValueChanged)));
 
    private static void OnValueChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
    {
        OrgChartView control = (OrgChartView)obj;
        XmlDataProvider provider = (XmlDataProvider)control.Resources["xdpOrgChart"];
        provider.Document = (XmlDocument)args.NewValue;
    }
 
    void SelectionChanged(object sender, RoutedEventArgs e)
    {
        XmlElement element = ((XmlElement)((TreeView)e.Source).SelectedItem);
        PositionSelected(this, new DataEventArgs<XmlElement>(element));
    }
 
    public XmlDocument Model
    {
        get { return (XmlDocument)GetValue(OrgChartDataSourceProperty); }
        set { SetValue(OrgChartDataSourceProperty, value); }
    }
 
    public event EventHandler<DataEventArgs<XmlElement>> PositionSelected = delegate { };
}

The Figure 5 shows the final design of the view (copied from the WPF Quickstart source code).

Figure 5
OrgCharView view

Checking the Results

Build and run the final solution by pressing F5. You will see both views from the EmployeeView and OrgChartView views loaded in the Shell:

Figure 6
Regenerated Quickstart running
If you click in a different block in the organization chart of the left view, you will see the corresponding employee information populated in the right view. This is accomplished with the EventAggregator service and the ShowEmployeeEvent event.

CompositeWPFContrib Wiki & Documentation Rss Feed

Updated Wiki: Home

Welcome to the Composite WPF Contrib project

News

What's in Prism Contrib?

Contributing to Composite WPF Contrib

Other p&p Contrib Projects

Updated Wiki: Windows Region Adapter

Window Region Adapter

Important Features

How to use

More Information

Updated Wiki: Documentation

Documentation

Updated Wiki: Windows Region Adapter

The WindowRegionAdapter

Important Features

How to use

More Information

Updated Wiki: Documentation

Documentation

Updated Wiki: Documentation

Documentation

Updated Wiki: Home

Welcome to the Composite WPF Contrib project

News

What's in Prism Contrib?

Contributing to Composite WPF Contrib

Other p&p Contrib Projects

Updated Wiki: Home

Welcome to the Composite WPF Contrib project

News

What's in Prism Contrib?

Contributing to Composite WPF Contrib

Other p&p Contrib Projects

Updated Wiki: WindsorAndLog4Net

Windsor Bootstrapper and Log4Net

Introduction

Using Boostrapper

Using Log4Net Logger

Using Windsor Adapter

Updated Wiki: WindsorAndLog4Net

Windsor Bootstrapper and Log4Net

Introduction

Using Boostrapper

Using Log4Net Logger

Using Windsor Adapter

Updated Wiki: Documentation

Documentation

Updated Wiki: Home

Welcome to the Composite WPF Contrib project

News

What's in Prism Contrib?

Contributing to Composite WPF Contrib

Other p&p Contrib Projects

Updated Wiki: Home

Welcome to the Composite WPF Contrib project

News

What's in Prism Contrib?

Contributing to Composite WPF Contrib

Other p&p Contrib Projects

Updated Wiki: WPFQuickstartRegeneratedWithCAL

Regenerating the WPF/SC-SF Quickstart with the Composite Application Library

Contents

Purpose

Prerequisites

Application Structure

Creating the initial solution

Preparing the Shell

Creating Modules

Creating Views

Checking the Results

Updated Wiki: WPFQuickstartRegeneratedWithCAL

Regenerating the WPF/SC-SF Quickstart with the Composite Application Library

Contents

Purpose

Prerequisites

Application Structure

Creating the initial solution

Preparing the Shell