WPF

Anonymous — Fri, 01 Dec 2017 07:35:11 GMT

Current Revision posted to WPF by Anonymous on 12/1/2017 7:35:11 AM

Spell Checking in the XamDataGrid

[Infragistics] Andrew Flick — Wed, 10 Jun 2009 12:30:14 GMT

Current Revision posted to WPF by [Infragistics] Andrew Flick on 6/10/2009 12:30:14 PM

Overview

Utilizing the Framework’s built-in capabilities for spell checking makes adding spell-checking support to the XamDataGrid a breeze.

The Code

Basically, you just need to turn on spell checking for the editor that is being used in the XamDataGrid. The default editor is the XamTextEditor. If you set this style at the Window level, every XamTextEditor will have spell checking enabled.

<Style TargetType="{x:Type igEditors:XamTextEditor}">
    <Setter Property="SpellCheck.IsEnabled" Value="True" />
</Style>

Tags: WPF, XamDataGrid

XamDataGrid :: Copying to Excel via the Clipboard

[Infragistics] Andrew Flick — Fri, 10 Apr 2009 11:18:21 GMT

Current Revision posted to WPF by [Infragistics] Andrew Flick on 4/10/2009 11:18:21 AM

One of the common tasks that many end-users have is to copy data from an application to Excel or Word or any other Windows Apps. The way to do this is to copy items to the Clipboard and Microsoft provides a really nice class that makes this simple to do. The point of this article is to offer a brief glimpse on how to copy cell values from the XamDataGrid to the clipboard. It will focus on three different selection strategies range select (only for contiguous ranges), record selection (rows), or field selections (columns).

Handling Selection in the XamDataGrid

To enable selection in the above three scenarios you may also want to make some modifications to the XamDataGrid that allow for the user to easily select a range of cells and allow them to select all of the cells in a field by clicking on a field header. The code to do this looks like this:

<igDP:XamDataGrid.FieldSettings>
	<igDP:FieldSettings LabelClickAction="SelectField" CellClickAction="SelectCell" />
</igDP:XamDataGrid.FieldSettings>

Managing Ctrl+C

To ensure that the XamDataGrid responds to Ctrl+C you need to add input bindings to the XamDataGrid that point to that particular keystroke. To do this you need to find a way to point the CTRL+C keystroke to an event or command that fires off the XamDataGrid. The code to handle this gesture looks like this:

<igDP:XamDataGrid.InputBindings>
    <KeyBinding Command="{x:Static myApp:Window1.CopyCommand}" Gesture="CTRL+C" />
</igDP:XamDataGrid.InputBindings>

Setting up the Copy Command

In the procedural code you now need to define this copy command. To do so, you need to declare it:

public static RoutedCommand CopyCommand = new RoutedCommand();

I hooked up this command in the constructor for our Window:

public Window1()
{
    CommandBinding copyCommandBinding = 
		new CommandBinding(CopyCommand, ExecutedCopyCommand);
    this.CommandBindings.Add(copyCommandBinding);
    InitializeComponent();
}

After you have the command bindings set up you can handle the ExecutedCopyCommand and this is what will actually be called by the CTRL+C method. In this method, I look at the XamDataGrid that calls the command and check to see which of the SelectedItemsCollections hold items and call a method to handle them based on the actual selected collection:

private void ExecutedCopyCommand(object sender, ExecutedRoutedEventArgs e)
{
    Infragistics.Windows.DataPresenter.XamDataGrid myGrid = 
		e.Source as Infragistics.Windows.DataPresenter.XamDataGrid;

    if (myGrid.SelectedItems.Cells.Count > 0)
        CopySelectedCells(myGrid);
    else if (myGrid.SelectedItems.Records.Count > 0)
        CopySelectedRecords(myGrid);
    else if (myGrid.SelectedItems.Fields.Count > 0)
        CopySelectedFields(myGrid);

}

Copy a Range of Cells

This method will enable the end-user to select a range of cells and format them appropriately to copy their text to clipboard. This formatting also enables the copying to be direct to rows/columns in Excel. One caveat is that it only allows for a contiguous range of cells (as this is the only capabilities enabled by Excel):

private static void CopySelectedCells(Infragistics.Windows.DataPresenter.XamDataGrid myGrid)
{
    string myInternalClipboard = null;
    int currentRecordLevel = 0;
    Infragistics.Windows.DataPresenter.SelectedCellCollection mySelectedCells = myGrid.SelectedItems.Cells;

    foreach (Cell myCell in mySelectedCells)
    {
        if (myInternalClipboard == null)
        {
            currentRecordLevel = myCell.Record.DataItemIndex;
            myInternalClipboard = myCell.Value.ToString();
        }
        else if (myCell.Record.DataItemIndex == currentRecordLevel)
            myInternalClipboard = myInternalClipboard + "\t" + myCell.Value.ToString();
        else
        {
            currentRecordLevel = myCell.Record.DataItemIndex;
            myInternalClipboard = myInternalClipboard + "\r\n" + myCell.Value.ToString();
        }
    }
    myInternalClipboard = myInternalClipboard + "\r\n";
    Clipboard.Clear();
    Clipboard.SetText(myInternalClipboard);
}

Copy a Range of Records

This method allows the end-user to select a record(row) or a range of rows and copy them to the clipboard and then past them to a particular app while still distinguishing different columns:

private static void CopySelectedRecords(Infragistics.Windows.DataPresenter.XamDataGrid myGrid)
{
    string myInternalClipboard = null;
    bool IsNewRecord = true;
    Infragistics.Windows.DataPresenter.SelectedRecordCollection mySelectedRecords = 
		myGrid.SelectedItems.Records;

    foreach (DataRecord myRecord in mySelectedRecords)
    {
        foreach(Cell myCell in myRecord.Cells)
        {
            if (myInternalClipboard == null || IsNewRecord == true)
            {
                myInternalClipboard = myInternalClipboard + myCell.Value.ToString();
                IsNewRecord = false;
            }
            else
                myInternalClipboard = myInternalClipboard + "\t" + myCell.Value.ToString();
        }
        IsNewRecord = true;
        myInternalClipboard = myInternalClipboard + "\r\n";
    }
    Clipboard.Clear();
    Clipboard.SetText(myInternalClipboard);
}

Copy a Range of Fields

This allows the end-user to select a column or a range of columns and copy those values to the clipboard. It was interesting to implement as when you select a field, you’re not actually selecting the cells in that field, but the entire field. So, you actually have to loop through all the records and build your clipboard string based on the parameters of the selected fields:

private static void CopySelectedFields(Infragistics.Windows.DataPresenter.XamDataGrid myGrid)
{
    string myInternalClipboard = null;
    bool IsNewRecord = true;
    Infragistics.Windows.DataPresenter.SelectedFieldCollection mySelectedFields = 
		myGrid.SelectedItems.Fields;

    foreach (DataRecord myRecord in myGrid.Records)
    {
        foreach (Field myField in mySelectedFields)
        {
            if (myInternalClipboard == null || IsNewRecord == true)
            {
                myInternalClipboard = myInternalClipboard + myRecord.Cells[myField].Value.ToString();
                IsNewRecord = false;
            }
            else
            {
                myInternalClipboard = myInternalClipboard + "\t" + myRecord.Cells[myField].Value.ToString();
            }
        }
        IsNewRecord = true;
        myInternalClipboard = myInternalClipboard + "\r\n";
    }
    Clipboard.Clear();
    Clipboard.SetText(myInternalClipboard);
}

Conclusion

That’s it. After adding this simple code to your application, you can now allow your end-users to copy from the XamDataGrid to an Excel file or to any Windows Application. You can download the code for this example here.

Tags: WPF, XamDataGrid, Excel

XamDataGrid :: Copying to Excel via the Clipboard

[Infragistics] Andrew Flick — Fri, 10 Apr 2009 11:17:05 GMT

Revision 1 posted to WPF by [Infragistics] Andrew Flick on 4/10/2009 11:17:05 AM

Handling Selection in the XamDataGrid

<igDP:XamDataGrid.FieldSettings>
	<igDP:FieldSettings LabelClickAction="SelectField" CellClickAction="SelectCell" />
</igDP:XamDataGrid.FieldSettings>

Managing Ctrl+C

<igDP:XamDataGrid.InputBindings>
    <KeyBinding Command="{x:Static myApp:Window1.CopyCommand}" Gesture="CTRL+C" />
</igDP:XamDataGrid.InputBindings>

Setting up the Copy Command

In the procedural code you now need to define this copy command. To do so, you need to declare it:

public static RoutedCommand CopyCommand = new RoutedCommand();

I hooked up this command in the constructor for our Window:

public Window1()
{
    CommandBinding copyCommandBinding = 
		new CommandBinding(CopyCommand, ExecutedCopyCommand);
    this.CommandBindings.Add(copyCommandBinding);
    InitializeComponent();
}

private void ExecutedCopyCommand(object sender, ExecutedRoutedEventArgs e)
{
    Infragistics.Windows.DataPresenter.XamDataGrid myGrid = 
		e.Source as Infragistics.Windows.DataPresenter.XamDataGrid;

    if (myGrid.SelectedItems.Cells.Count > 0)
        CopySelectedCells(myGrid);
    else if (myGrid.SelectedItems.Records.Count > 0)
        CopySelectedRecords(myGrid);
    else if (myGrid.SelectedItems.Fields.Count > 0)
        CopySelectedFields(myGrid);

}

Copy a Range of Cells

private static void CopySelectedCells(Infragistics.Windows.DataPresenter.XamDataGrid myGrid)
{
    string myInternalClipboard = null;
    int currentRecordLevel = 0;
    Infragistics.Windows.DataPresenter.SelectedCellCollection mySelectedCells = myGrid.SelectedItems.Cells;

    foreach (Cell myCell in mySelectedCells)
    {
        if (myInternalClipboard == null)
        {
            currentRecordLevel = myCell.Record.DataItemIndex;
            myInternalClipboard = myCell.Value.ToString();
        }
        else if (myCell.Record.DataItemIndex == currentRecordLevel)
            myInternalClipboard = myInternalClipboard + "\t" + myCell.Value.ToString();
        else
        {
            currentRecordLevel = myCell.Record.DataItemIndex;
            myInternalClipboard = myInternalClipboard + "\r\n" + myCell.Value.ToString();
        }
    }
    myInternalClipboard = myInternalClipboard + "\r\n";
    Clipboard.Clear();
    Clipboard.SetText(myInternalClipboard);
}

Copy a Range of Records

This method allows the end-user to select a record(row) or a range of rows and copy them to the clipboard and then past them to a particular app while still distinguishing different columns:

private static void CopySelectedRecords(Infragistics.Windows.DataPresenter.XamDataGrid myGrid)
{
    string myInternalClipboard = null;
    bool IsNewRecord = true;
    Infragistics.Windows.DataPresenter.SelectedRecordCollection mySelectedRecords = 
		myGrid.SelectedItems.Records;

    foreach (DataRecord myRecord in mySelectedRecords)
    {
        foreach(Cell myCell in myRecord.Cells)
        {
            if (myInternalClipboard == null || IsNewRecord == true)
            {
                myInternalClipboard = myInternalClipboard + myCell.Value.ToString();
                IsNewRecord = false;
            }
            else
                myInternalClipboard = myInternalClipboard + "\t" + myCell.Value.ToString();
        }
        IsNewRecord = true;
        myInternalClipboard = myInternalClipboard + "\r\n";
    }
    Clipboard.Clear();
    Clipboard.SetText(myInternalClipboard);
}

Copy a Range of Fields

private static void CopySelectedFields(Infragistics.Windows.DataPresenter.XamDataGrid myGrid)
{
    string myInternalClipboard = null;
    bool IsNewRecord = true;
    Infragistics.Windows.DataPresenter.SelectedFieldCollection mySelectedFields = 
		myGrid.SelectedItems.Fields;

    foreach (DataRecord myRecord in myGrid.Records)
    {
        foreach (Field myField in mySelectedFields)
        {
            if (myInternalClipboard == null || IsNewRecord == true)
            {
                myInternalClipboard = myInternalClipboard + myRecord.Cells[myField].Value.ToString();
                IsNewRecord = false;
            }
            else
            {
                myInternalClipboard = myInternalClipboard + "\t" + myRecord.Cells[myField].Value.ToString();
            }
        }
        IsNewRecord = true;
        myInternalClipboard = myInternalClipboard + "\r\n";
    }
    Clipboard.Clear();
    Clipboard.SetText(myInternalClipboard);
}

Conclusion

Tags: WPF, XamDataGrid, Excel

Validation in the XamDataGrid

[Infragistics] Andrew Flick — Mon, 06 Apr 2009 16:41:12 GMT

Current Revision posted to WPF by [Infragistics] Andrew Flick on 4/6/2009 4:41:12 PM

Validation in the XamDataGrid is currently handled through the ValueConstraint class off of the Editors. Using this class you can do things like set a trigger to change the border of a cell to red when an invalid value it entered. This article shows off how to use the ValueConstraints class.

The first thing to understand is that there are multiple types of constraints and they include the following:

FixedValue Condition – Does the value equal this?
Enumeration Condition – An Object implementing IEnumerable which contains a list of values.
MaxExclusive Condition – The value must be less than this.
MaxInclusive Condition – The max value that the constrained value can be.
MinExclusive Condition – The value must be greater than this.
MinInclusive Condition – The min value that the constrained value can be.
Min/MaxLength Condition – The length of type string must be greater/less than this.
Nullable Condition – Whether the constrained value can be null.
RegExPattern Condition – A regular expression for the value.

Using BindToSampleData property on the XamDataGrid to practice validation.

Enumeration of Fixed Values:

<igDP:Field Name="department" Label="Department">
    <igDP:Field.Settings>
        <igDP:FieldSettings EditorType="{x:Type igEdit:XamTextEditor}">
            <igDP:FieldSettings.EditorStyle>
                <Style TargetType="{x:Type igEdit:ValueEditor}">
                    <Style.Resources>
                        <x:Array Type="sys:String" x:Key="FixedValue">
                            <sys:String>Admin</sys:String>
                            <sys:String>Sales</sys:String>
                            <sys:String>Human Resources</sys:String>
                        </x:Array>
                    </Style.Resources>
                    <Style.Setters>
                        <Setter Property="ValueConstraint">
                            <Setter.Value>
                                <igEdit:ValueConstraint Enumeration="{StaticResource FixedValue}" />
                            </Setter.Value>
                        </Setter>
                        <Setter Property="InvalidValueBehavior" Value="RetainValue" />
                    </Style.Setters>
                    <Style.Triggers>
                        <Trigger Property="IsValueValid" Value="false">
                            <Trigger.Setters>
                                <Setter Property="BorderBrush" Value="Red" />
                            </Trigger.Setters>
                        </Trigger>
                    </Style.Triggers>
                </Style>
            </igDP:FieldSettings.EditorStyle>
        </igDP:FieldSettings>
    </igDP:Field.Settings>
</igDP:Field>

Max/Min Inclusive:

<igDP:Field Name="salary" Label="Salary">
    <igDP:Field.Settings>
        <igDP:FieldSettings EditorType="{x:Type igEdit:XamCurrencyEditor}" EditAsType="{x:Type sys:Double}">
            <igDP:FieldSettings.EditorStyle>
                <Style TargetType="{x:Type igEdit:ValueEditor}">
                    <Style.Setters>
                        <Setter Property="ValueConstraint">
                            <Setter.Value>
                                <igEdit:ValueConstraint MinInclusive="0" MaxInclusive="100000" />
                            </Setter.Value>
                        </Setter>
                        <Setter Property="InvalidValueBehavior" Value="RetainValue" />
                    </Style.Setters>
                    <Style.Triggers>
                        <Trigger Property="IsValueValid" Value="false">
                            <Trigger.Setters>
                                <Setter Property="BorderBrush" Value="Red" />
                            </Trigger.Setters>
                        </Trigger>
                    </Style.Triggers>
                </Style>
            </igDP:FieldSettings.EditorStyle>
        </igDP:FieldSettings>
    </igDP:Field.Settings>
</igDP:Field>

Reg-Ex for an E-Mail:

<igDP:Field Name="email" Label="E-Mail">
    <igDP:Field.Settings>
        <igDP:FieldSettings EditorType="{x:Type igEdit:XamTextEditor}">
            <igDP:FieldSettings.EditorStyle>
                <Style TargetType="{x:Type igEdit:ValueEditor}">
                    <Style.Setters>
                        <Setter Property="ValueConstraint">
                            <Setter.Value>
                                <igEdit:ValueConstraint RegexPattern="^(([a-zA-Z0-9_\-\.]+)@([a-zA-Z0-9_\-\.]+)\.([a-zA-Z]{2,5}){1,25})+([;.](([a-zA-Z0-9_\-\.]+)@([a-zA-Z0-9_\-\.]+)\.([a-zA-Z]{2,5}){1,25})+)*$" />
                            </Setter.Value>
                        </Setter>
                        <Setter Property="InvalidValueBehavior" Value="RetainValue" />
                    </Style.Setters>
                    <Style.Triggers>
                        <Trigger Property="IsValueValid" Value="false">
                            <Trigger.Setters>
                                <Setter Property="BorderBrush" Value="Red" />
                            </Trigger.Setters>
                        </Trigger>
                    </Style.Triggers>
                </Style>
            </igDP:FieldSettings.EditorStyle>
        </igDP:FieldSettings>
    </igDP:Field.Settings>
</igDP:Field>

EditModeValidationError Event

So, your user has failed the validation logic that you’ve put in place. When this happens the EditModeValidationError Event fires and allows you to perform some action. For instance, you can configure the error message as follows:

private void xamDataGrid1_EditModeValidationError(object sender, Infragistics.Windows.DataPresenter.Events.EditModeValidationErrorEventArgs e)
{
    switch (e.Cell.Field.Name.ToString())
    {
        case "department":
            e.ErrorMessage = "That department does not exist!  Please enter a valid department."
            break;
        case "salary":
            e.ErrorMessage = "Salary cannot be more than $100,000.00";
            break;
        case "email":
            e.ErrorMessage = "Please enter an e-mail address (e.g. __@__.com)";
            break;
    }
}

Conclusion

That wraps up this article on validation in the XamDataGrid. Now keep in mind that this works with all of our editors as well; so you’re not…constrained…to the XamDataGrid to use these capabilities. You can grab the code for this sample here.

Tags: WPF, XamDataGrid

Hosting a WPF Control in a Windows Forms Application

[Infragistics] Andrew Flick — Mon, 09 Mar 2009 08:56:16 GMT

Current Revision posted to WPF by [Infragistics] Andrew Flick on 3/9/2009 8:56:16 AM

Getting Started

WPF to Windows Forms Interop is one of the development strategies that will take existing applications and bring them to the future. WPF currently provides the ability to fairly easily create new experiences for visualizing applications. Windows Forms has the tools, the frameworks, and years of development effort invested into its existence. If you have a legacy application in Windows Forms and wish to add new experiences to it or better ways to visualize information; then Interop is the way to go.

Infragistics has released its first WPF controls and included in this suite of controls are new metaphors for visualizing information or for that matter creating navigation items. It makes perfect sense to include these controls inside of existing Windows Forms Applications.

Adding References

To begin we'll focus on the first challenge in integration, which is to get the WPF control (in this case the XamDataPresenter) into the Windows Forms Application. First you need to add references to the Microsoft WPF assemblies that handle WPF, the assemblies are as follows:

PresentationFramework
PresentationCore
WindowsBase
WindowsFormsIntegration

After adding references to the Microsoft assemblies, next add references to the Infragistics assemblies which include:

Infragistics3.Windows.DataPresenter.v7.1
Infragistics3.Windows.v7.1
Infragistics3.Windows.Editors.v7.1

Hosting the xamDataPresenter in an ElementHost for Windows Forms Apps

Next, you'll need to add code to host the WPF control inside the Windows Forms application. In the case of this sample, I'll perform the core logic inside of the Form_Load event. The main piece of code revolves around the ElementHost object; which is a container that is used to hold an element [e.g. WPF Control].

For the purpose of this sample, I'll also create an instance of the XamDataPresenter and assign its DataSource property. Then, I'll need to associate the XamDataPresenter as a child of the ElementHost object. The code will look something like this:

…
using System.Windows.Forms.Integration;
…

namespace WindowsForms_WPF_InteropDemo
{
	public partial class Main: Form
	{
		private ElementHost XamHost;
		private Infragistics.Windows.DataPresenter.XamDataPresenter XamDP;
		…

		private void Form1_Load(object sender, EventArgs e)
		{
			XamHost = new ElementHost();
			XamHost.Dock = DockStyle.Fill;
			this.Controls.Add(XamHost);
			XamDP = new Infragistics.Windows.DataPresenter.XamDataPresenter();
			XamDP.DataSource = this.vSalesPersonSalesByFiscalYearsBindingSource;
			XamHost.Child = XamDP;

		}
…

This implementation is fairly easy to achieve, gives us access to the full XamDataPresenter object model and it was only a few lines of code. This will enable developers to fully target the control inside of Visual Studio.

Designing for WPF – Building for Windows Forms

One of the core concepts for WPF development was the separation of Design from Development. This means you might want to open up the XamDataPresenter inside of Blend and style it in order to fully achieve the experience that you wish to deliver. Now, you could do all of the work on a 'dummy' control inside of Blend and cut-copy-paste the XAML code into your Windows Forms project, but that isn't really a good scenario and breaks down the communication between the two tooling environments and if I want to fully utilize the power of WPF styling capabilities then I should look for another approach.

One way to get around the problem that I've mentioned is to create a WPF Control Library that hosts the XamDataPresenter. This will enable me to fully design the control inside of Blend and I will be able to host the ControlLibrary as the control inside of ElementHost within Visual Studio. (Note: Control Libraries can be built in Blend, but unless you add them to a dummy project they cannot be tested/run.)

The first challenge I will face is that there is no assigned data source; to get around this I can create a simple XML file that mimics my datasource and I can use that as an intermediate step to style my XamDataPresenter or I can set the BindToSampleData property which will fill my XamDataPresenter with a generic set of data and enable me to focus purely on the styling aspects of the control. That being said, I now have all of the abilities as a designer like the ability to visually style the control and add custom presenters.

After making all of the design changes, I can simply build my project and either a.) add the project to my Windows Forms Solution or b.) add the DLL for my custom control to the references in the Windows Forms Project.

Exposing WPF Properties

Inside of Visual Studio, I associate the UserControl to the element host by following the same process as previously noted. I will notice that there is no DataSource property, and in fact, none of the familiar properties that I had in my first sample are there. As a matter of fact, I am now seeing all of the properties of the UserControl and not that of the XamDataPresenter. The ideal solution is to have both the ability to design in Blend and code inside of Visual Studio. To achieve this, I'll have to add some code to my UserControl that exposes the underlying properties of the XamDataPresenter.

To begin, I'll start by adding a public property to my UserControl that lets me access the datasource property of the XamDataPresenter. The code might look something like this:

public System.Collections.IEnumerable DataSource
{
	get { return this.XamDataPresenterInternal.DataSource; }
	set { this.XamDataPresenterInternal.DataSource = value; }
}

Listening to WPF Events

Theoretically, I can expose all of the properties I need on the underlying XamDataPresenter by associating them as public properties of the usercontrol. Aside from properties, I may also need to expose some events to my base project. In this sample, I'll add some events that validate cell values before exiting edit mode on a grid cell. Since, the EditModeEndingEvent will not be available in my Windows Forms Application, I'll create a public event off of the user control that will handle the event off of the underlying XamDataPresenter and let me act on it inside of my Windows Forms Application. The following code will be placed in my .xaml.cs file:

public static RoutedEvent EditModeEndingEvent = EventManager.RegisterRoutedEvent
   ("EditModeEnding", RoutingStrategy.Bubble, typeof(RoutedEventHandler),
   typeof(XamDataPresenterWrapper));

public event RoutedEventHandler EditModeEnding
{
	add { AddHandler(EditModeEndingEvent, value); }
	remove { RemoveHandler(EditModeEndingEvent, value); }
}

 
void XamDataPresenterInternal_EditModeEnding(object sender,
   Infragistics.Windows.DataPresenter.Events.EditModeEndingEventArgs e)
{
  RaiseEvent(new
     RoutedEventArgs(XamDataPresenterWrapper.EditModeEndingEvent, e));
}

Also, make sure that the .xaml file knows of the event:

<igDP:XamDataPresenter Name="XamDataPresenterInternal"
 EditModeEnding="XamDataPresenterInternal_EditModeEnding"/>

Connecting the WPF Control Library to the Windows Forms Project

Now that I've handled these changes to my ControlLibrary, I'm going to build it and then jump back into my Windows Forms Project and start hooking everything up. To begin, I'll start by hooking up the DataSource Property:

…
using System.Windows.Forms.Integration;
…

namespace WindowsForms_WPF_InteropDemo
{
	public partial class Main: Form
	{
		private ElementHost XamHost;
		private Infragistics.XamDataPresenterWrapper XamDataPresenter;
		…
		private void Main_Load(object sender, EventArgs e)
		{
			…
			XamHost = new ElementHost();
			XamHost.Dock = DockStyle.Fill;
			this.Controls.Add(XamHost);
			XamDataPresenter = new Infragistics.XamDataPresenterWrapper();
			XamDataPresenter.DataSource =
				this.vSalesPersonSalesByFiscalYearsBindingSource;
			XamHost.Child = XamDataPresenter;
		}

…

After completing this work item, I can hook up the event and perform any logic in that event that I need to handle. For the purpose of this sample, I'll add the event handler to the (Main_Load) Form_Load event and then I'll add the code to perform whatever logic is needed.

…
using Infragistics.Windows.DataPresenter.Events;
…

XamDataPresenter.EditModeEnding += 
  new System.Windows.RoutedEventHandler(XamDataPresenter_EditModeEnding);

…

void XamDataPresenter_EditModeEnding(object sender, System.Windows.RoutedEventArgs e)
{
	// Arguments for the Edit Mode Ending Event
	EditModeEndingEventArgs editEndingArgs = e.OriginalSource as
		EditModeEndingEventArgs;
	
	if (editEndingArgs == null)
		return;

 	// Column name of the field being edited (Infragistics.Windows.DataPresenter.Events)
	string columnName = editEndingArgs.Cell.Field.Name;

	// Value of the edited Cell (after edits were made)
	string newCellValue = editEndingArgs.Editor.Text;

	if (columnName == "Title" )
	{
		// Check the New Cell Value to see if it changed to anything other
		// than Sales Representative
		if (newCellValue != "Sales Representative")
		{
			//Do not persist the changes	
			editEndingArgs.AcceptChanges = false;
			MessageBox.Show("Title Must Be Sales Representative");
		}
	}
}
…

In this case, making sure that all of the "Sales Representatives" remain "Sales Representatives" was my task.

Expanding Rich Client Experiences

After completing these steps, here is the much anticipated screenshot showing the Grid View of the XamDataPresenter inside of a Windows Forms application (minus some cool transition/animation effects).

Next, witness this screenshot of the Carousel View of the XamDataPresenter also hosted within a Windows Forms application.

A Word on Type Dependencies

Note: You'll notice that I'm utilizing the underlying Infragistics EditModeEndingEventArgs in my Windows Forms application. This means that I need to have a reference to the Infragistics WPF assemblies in order to achieve this. If for some reason, you do not want to include a dependency on the Infragistics WPF assemblies then you can use reflection, and do something like this (although, I would recommend just using the NetAdvantage WPF Assemblies):

void XamDataPresenter_EditModeEnding(object sender, System.Windows.RoutedEventArgs e)
{
	//Find the Cell Object that was edited
	object cell = e.OriginalSource.GetType().GetProperty("Cell").GetValue(
		e.OriginalSource, null);
	
	//Get the field that the cell belongs to
	object field = cell.GetType().GetProperty("Field").GetValue(cell, null);

	//Get the name of the field that the cell belongs to
	string name = field.GetType().GetProperty("Name").GetValue(field, null) as string;
 
	//Check and see if column name is Title
	if (name == "Title")	
	{
		//Get to the text typed by the user
		object editor = e.OriginalSource.GetType().GetProperty("Editor").GetValue(
		  e.OriginalSource, null);
		
		string text = editor.GetType().GetProperty("Text").GetValue(editor, null) as string;

		//Check to see if the text has changed from Sales Representative
		if (text != "Sales Representative")
		{
			e.OriginalSource.GetType().GetProperty("AcceptChanges").SetValue(
			  e.OriginalSource, false, null);
			
			MessageBox.Show("Title Must Be Sales Representative");
		}
	}
}

Conclusion

If you're a developer, do everything in Visual Studio and rely on the styling that we provide. If you have a graphic designer or need Blend interaction, then perhaps wrapping the control inside of a control library is a smarter choice, as it helps keep the separation of roles in place.

Lastly, there are some limitations to the Interop story that are important to note. For instance, you can only host one child per element host control, WPF and Windows Forms have different scaling models, or it’s not possible to nest an ElementHost inside of a WindowsFormsHost or vice versa. To read a complete list of limitations you can visit http://blogs.msdn.com/scoberry/archive/2006/09/01/735844.aspx.

Enjoy expanding your Rich Client Experiences!

XML Databinding with the XamDataGrid

[Infragistics] Andrew Flick — Sat, 28 Feb 2009 13:10:24 GMT

Current Revision posted to WPF by [Infragistics] Andrew Flick on 2/28/2009 1:10:24 PM

XML Data File

Start with having an XML Datasource for the purpose of this example we’ll use the following and it will be stored in a separate XML File titled SalesPeople.xml:

<divre name="code" class="xml"></divre><SalesPeople> <SalesPerson> <FirstName>Stephen</FirstName> <LastName>Jiang</LastName> <JobTitle>Sales Representative</JobTitle> <City>Redmond</City> <State>Washington</State> <PostalCode>98052</PostalCode> <SalesYTD>677588.46</SalesYTD> <SalesLastYear>22134322.42</SalesLastYear> </SalesPerson> <SalesPerson> <FirstName>Michael</FirstName> <LastName>Blythe</LastName> <JobTitle>Sales Representative</JobTitle> <City>Detroit</City> <State>Michigan</State> <PostalCode>48226</PostalCode> <SalesYTD>4557045.04</SalesYTD> <SalesLastYear>1740406.47</SalesLastYear> </SalesPerson> </SalesPeople> <divre></divre> <divre></divre>

XML in our Application

Next, we need to set this data up for use inside our application. In the case of this sample,
I’ve set our XamDataGrid into a GridPanel and set the DataContext of that grid to point at our XML Data. We’ll set the source property of the XMLDataProvider equal to the file location in this case in a folder titled Data. Then we’ll set the XPath to point to our SalesPersons. This will look something like this:

Initial Binding to the XamDataGrid

Next, using simple WPF Binding, we can bind the xml file to the XamDataGrid:

Customizing Field Settings

Lastly, we may want to do something like enable Summaries on the xamDataGrid and will notice that everything is being picked up as a string. To get around this we can format our data as the appropriate type by adding the Fields and associating the appropriate types to those fields. Note: We can also format the field’s labels to achieve something like “First Name” rather than “FirstName.”

After this our data is all set up and ready to go. We have successfully bound our grid to an XML File.

Tags: databinding, WPF, XamDataGrid

Hosting a WPF Control in a Windows Forms Application

[Infragistics] Andrew Flick — Sat, 28 Feb 2009 12:35:01 GMT

Revision 1 posted to WPF by [Infragistics] Andrew Flick on 2/28/2009 12:35:01 PM

Getting Started

Adding References

PresentationFramework
PresentationCore
WindowsBase
WindowsFormsIntegration

After adding references to the Microsoft assemblies, next add references to the Infragistics assemblies which include:

Infragistics3.Windows.DataPresenter.v7.1
Infragistics3.Windows.v7.1
Infragistics3.Windows.Editors.v7.1

Hosting the xamDataPresenter in an ElementHost for Windows Forms Apps

…
using System.Windows.Forms.Integration;
…

namespace WindowsForms_WPF_InteropDemo
{
	public partial class Main: Form
	{
		private ElementHost XamHost;
		private Infragistics.Windows.DataPresenter.XamDataPresenter XamDP;
		…

		private void Form1_Load(object sender, EventArgs e)
		{
			XamHost = new ElementHost();
			XamHost.Dock = DockStyle.Fill;
			this.Controls.Add(XamHost);
			XamDP = new Infragistics.Windows.DataPresenter.XamDataPresenter();
			XamDP.DataSource = this.vSalesPersonSalesByFiscalYearsBindingSource;
			XamHost.Child = XamDP;

		}
…

Designing for WPF – Building for Windows Forms

Exposing WPF Properties

To begin, I'll start by adding a public property to my UserControl that lets me access the datasource property of the XamDataPresenter. The code might look something like this:

public System.Collections.IEnumerable DataSource
{
	get { return this.XamDataPresenterInternal.DataSource; }
	set { this.XamDataPresenterInternal.DataSource = value; }
}

Listening to WPF Events

public static RoutedEvent EditModeEndingEvent = EventManager.RegisterRoutedEvent
   ("EditModeEnding", RoutingStrategy.Bubble, typeof(RoutedEventHandler),
   typeof(XamDataPresenterWrapper));

public event RoutedEventHandler EditModeEnding
{
	add { AddHandler(EditModeEndingEvent, value); }
	remove { RemoveHandler(EditModeEndingEvent, value); }
}

 
void XamDataPresenterInternal_EditModeEnding(object sender,
   Infragistics.Windows.DataPresenter.Events.EditModeEndingEventArgs e)
{
  RaiseEvent(new
     RoutedEventArgs(XamDataPresenterWrapper.EditModeEndingEvent, e));
}

Also, make sure that the .xaml file knows of the event:

<igDP:XamDataPresenter Name="XamDataPresenterInternal"
 EditModeEnding="XamDataPresenterInternal_EditModeEnding"/>

Connecting the WPF Control Library to the Windows Forms Project

…
using System.Windows.Forms.Integration;
…

namespace WindowsForms_WPF_InteropDemo
{
	public partial class Main: Form
	{
		private ElementHost XamHost;
		private Infragistics.XamDataPresenterWrapper XamDataPresenter;
		…
		private void Main_Load(object sender, EventArgs e)
		{
			…
			XamHost = new ElementHost();
			XamHost.Dock = DockStyle.Fill;
			this.Controls.Add(XamHost);
			XamDataPresenter = new Infragistics.XamDataPresenterWrapper();
			XamDataPresenter.DataSource =
				this.vSalesPersonSalesByFiscalYearsBindingSource;
			XamHost.Child = XamDataPresenter;
		}

…

…
using Infragistics.Windows.DataPresenter.Events;
…

XamDataPresenter.EditModeEnding += 
  new System.Windows.RoutedEventHandler(XamDataPresenter_EditModeEnding);

…

void XamDataPresenter_EditModeEnding(object sender, System.Windows.RoutedEventArgs e)
{
	// Arguments for the Edit Mode Ending Event
	EditModeEndingEventArgs editEndingArgs = e.OriginalSource as
		EditModeEndingEventArgs;
	
	if (editEndingArgs == null)
		return;

 	// Column name of the field being edited (Infragistics.Windows.DataPresenter.Events)
	string columnName = editEndingArgs.Cell.Field.Name;

	// Value of the edited Cell (after edits were made)
	string newCellValue = editEndingArgs.Editor.Text;

	if (columnName == "Title" )
	{
		// Check the New Cell Value to see if it changed to anything other
		// than Sales Representative
		if (newCellValue != "Sales Representative")
		{
			//Do not persist the changes	
			editEndingArgs.AcceptChanges = false;
			MessageBox.Show("Title Must Be Sales Representative");
		}
	}
}
…

In this case, making sure that all of the "Sales Representatives" remain "Sales Representatives" was my task.

Expanding Rich Client Experiences

Next, witness this screenshot of the Carousel View of the XamDataPresenter also hosted within a Windows Forms application.

A Word on Type Dependencies

void XamDataPresenter_EditModeEnding(object sender, System.Windows.RoutedEventArgs e)
{
	//Find the Cell Object that was edited
	object cell = e.OriginalSource.GetType().GetProperty("Cell").GetValue(
		e.OriginalSource, null);
	
	//Get the field that the cell belongs to
	object field = cell.GetType().GetProperty("Field").GetValue(cell, null);

	//Get the name of the field that the cell belongs to
	string name = field.GetType().GetProperty("Name").GetValue(field, null) as string;
 
	//Check and see if column name is Title
	if (name == "Title")	
	{
		//Get to the text typed by the user
		object editor = e.OriginalSource.GetType().GetProperty("Editor").GetValue(
		  e.OriginalSource, null);
		
		string text = editor.GetType().GetProperty("Text").GetValue(editor, null) as string;

		//Check to see if the text has changed from Sales Representative
		if (text != "Sales Representative")
		{
			e.OriginalSource.GetType().GetProperty("AcceptChanges").SetValue(
			  e.OriginalSource, false, null);
			
			MessageBox.Show("Title Must Be Sales Representative");
		}
	}
}

Conclusion

Enjoy expanding your Rich Client Experiences!

Tags: WPF, Windows Forms, Interop

Tangerine -- A WPF Reference Application

[Infragistics] Andrew Flick — Sat, 28 Feb 2009 12:31:54 GMT

Current Revision posted to WPF by [Infragistics] Andrew Flick on 2/28/2009 12:31:54 PM

Introduction

Use Tangerine™, our first reference application for WPF, to not only learn WPF and NetAdvantage for WPF but also to learn good practices for enterprise application development across the board. This solution provides a full application, including complete source code, as well as several accompanying papers to help guide you in your application development. In addition to using it as a learning tool, the solution has been architected in such a way as to make it easy for you to reuse it in your own development, either in whole or in part.

Tangerine v1.1 is a WPF-based asset browser application. It has a pluggable architecture so that you can provide any number of different back-end asset providers while reusing the same snazzy UI that's based on Infragistics NetAdvantage for WPF toolset. In our first release, we have supplied an Amazon Web Services' E-Commerce Service provider so that you can use the application to browse and search the Amazon.com catalog. You can use the links below to both run the application (via ClickOnce deployment) now or download the solution and papers.

To learn more about the solution, check out Introducing Tangerine, which describes the tools we used to build Tangerine as well as an overview of its accompanying papers.

Experience Tangerine Now

Experience Tangerine now via ClickOnce deployment. Double-check your computer meets the minimum requirements prior to launching.

Minimum Requirements to Run:

Windows Vista® or Windows® Server 2008
Windows XP & Windows Server 2003 Users: Verify you have the .NET Framework 3.0 or .NET Framework 3.5 installed

Get Tangerine

Generally speaking, the only tool you need in addition to all the usual stuff needed to develop WPF is NetAdvantage for WPF. If you don't own it, you can download a trial for free.

Minimum Requirements for Development:

Microsoft Visual Studio 2008
.NET Framework 3.0 or .NET Framework 3.5 (installed by default on Windows Vista and Windows Server 2008)
Infragistics NetAdvantage for WPF (trial or registered will work)

Delve into Tangerine

The best way to really dive into Tangerine is to go ahead and download the complete solution so that you can explore the code. However, for your convenience, you can delve into the accompanying papers online.

Introducing Tangerine (PDF/XPS) [~1.2 MB] - The best way to get started learning about the solution.
Story (PDF/XPS) [~800 KB] - Tells the story of the application's development, including key decisions and problems solved along the way.
Vision & Scope (PDF/XPS) [~410 KB] - The original, unaltered vision & scope document that started the development process that you can use as an example and to get a feel for how the application changed over time. It is an artifact of the application's development.
Requirements (PDF/XPS) [~650 KB] - The original, unaltered requirements document that can be used as an example of how to do scenario-based requirements without falling into the rut of prescribing an implementation. It is another artifact of our development.
Architecture (PDF/XPS) [~700 KB] - An architectural overview of the solution—a good starting point before delving into the code.
Perspectives on WPF (PDF/XPS) [~370 KB] - Discusses learning WPF from the viewpoint of different developer/designer roles.

Tags: WPF, Reference Application, XamDataGrid, xamDataCarousel

Using the Infragistics WinGrid in a WPF Application

[Infragistics] Andrew Flick — Sat, 28 Feb 2009 11:48:41 GMT

Current Revision posted to WPF by [Infragistics] Andrew Flick on 2/28/2009 11:48:41 AM

In some scenarios, developers may find themselves in a situation where they are using the Infragistics WinGrid wrapped with some pretty intensive business logic that is going to take a good deal of time to recreate. One possibility that the developer can use is to continue forward with a WPF application and simply re-use the WinGrid in that application. This article demonstrates the necessary libraries to do that.

The first thing that needs to be done is to add references to the WindowsFormsIntegration dll and if you have a separate project hosting your WinForms control include that as well. With the addition of this WindowsFormsIntegration dll, you will be able to add a WindowsFormsHost component to your WPF application. To Display your Windows Forms control simply set the Child property and ensure you have a reference to the control. The following code snippet shows a WinGrid and a Carousel on the same Window.

<Window x:Class="XamWinFormsInteropSample.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="517" Width="680"
        xmlns:igDP="http://infragistics.com/DataPresenter"
        xmlns:WinGrid="clr-namespace:xamWinGrid;assembly=xamWinGrid"
 	  Loaded="Window_Loaded">
    <Grid x:Name="MainGrid">
        <Grid.RowDefinitions>
            <RowDefinition Height="162*" />
            <RowDefinition Height="100*" />
        </Grid.RowDefinitions>
        <WindowsFormsHost Name="windowsFormsHost1">
            <WinGrid:xamWinGrid x:Name="xamWinGrid1" />
        </WindowsFormsHost>
        <igDP:XamDataCarousel Name="xamDataPresenter1" Grid.Row="1" />
    </Grid>
</Window>

One other thing that can be done is in the user-control for the WindowsForms control; you can have a public property that exposes anything on the underlying controls that you may want to have access to in the WPF application. In this example, I will expose the DataSource property so that I can bind to a NorthWind dataset:

//Windows Forms User-Control
public System.Collections.IEnumerable DataSource
{
set
      {
      	this.ultraGrid1.DataSource = value;
}
}

To set up binding in a hybrid scenario, you can use the System.Windows.Forms.BindingSource control. An example from Microsoft is well documented here: http://msdn.microsoft.com/en-us/library/ms742687.aspx . That sample is the basis for the binding listed in this sample:

//WPF Application
private System.Windows.Forms.BindingSource nwBindingSource;
private NwindDataSet nwDataSet;
private NwindDataSetTableAdapters.CustomersTableAdapter customersTableAdapter = 
    new XamWinFormsInteropSample.NwindDataSetTableAdapters.CustomersTableAdapter();

        
public Window1()
{
InitializeComponent();
      this.nwDataSet = new NwindDataSet();
      this.nwDataSet.DataSetName = "nwDataSet";

      this.nwBindingSource = new System.Windows.Forms.BindingSource();
      this.nwBindingSource.DataSource = this.nwDataSet;

}

private void Window_Loaded(object sender, RoutedEventArgs e)
{
this.customersTableAdapter.ClearBeforeFill = true;
      this.customersTableAdapter.Fill(this.nwDataSet.Customers);

 	this.MainGrid.DataContext = this.nwBindingSource;
      this.xamDataPresenter1.DataSource = this.nwBindingSource;
      this.xamWinGrid1.DataSource = this.nwBindingSource;

      BindingListCollectionView cv = 
CollectionViewSource.GetDefaultView(this.nwBindingSource) as 
BindingListCollectionView;

cv.CurrentChanged += new EventHandler(cv_CurrentChanged);
            
}

void cv_CurrentChanged(object sender, EventArgs e)
{
BindingListCollectionView cv = sender as BindingListCollectionView;
      this.nwBindingSource.Position = cv.CurrentPosition;
}

After doing this, you have officially included a Windows Forms Control in your WPF Application:

For additional information on this subject check out these links:

Property Mapping: http://msdn.microsoft.com/en-us/library/ms788729.aspx
General Issues with Interop: http://blogs.msdn.com/scoberry/archive/2006/09/01/735844.aspx

Tags: WPF, WinGrid, Windows Forms, Interop

Printing the XamDataGrid with Infragistics.Reports

[Infragistics] Andrew Flick — Sat, 28 Feb 2009 11:36:18 GMT

Current Revision posted to WPF by [Infragistics] Andrew Flick on 2/28/2009 11:36:18 AM

Introduction

Infragistics.Reports is an extremely versatile and powerful code library included in the NetAdvantage for WPF product. Initially, it was created to enable developers an easy mechanism for printing the XamDataGrid or exporting it to XPS. As the control API took shape, new capabilities emerged granting the developer the ability to customize the document by adding header/footers or custom graphics. As we looked at ways for how to push stuff to the printer, it became apparent that we could just print the entire window or place basically any visual element out to the printer. This gives the ability to push the chart or images or whatever you want out. Then some helper controls were added to the library, things to help with the full document printing/exporting experience such as a Print Preview control. This article demonstrates the usage of printing the XamDataGrid and associating a report to the printer.

Setting up Infragistics.Reports

The first thing that you have to do is add a reference to the Infragistics3.Wpf.Reporting dll. This holds all the critical pieces to write out to the printer/XPS document. Then you need to new up a Report class. This is the piece that is going to be printed. A report consists of a collection of sections. Each of these sections can hold some type of content. A key class that will be most useful is the Infragistics.Windows.Reports.EmbeddedVisualReportSection as this will easily map any visual element to a section.

Infragistics.Windows.Reporting.Report myReport = new  
   Infragistics.Windows.Reporting.Report();

Infragistics.Windows.Reporting.EmbeddedVisualReportSection 
myXamDataGridReport = new
Infragistics.Windows.Reporting.EmbeddedVisualReportSection(this.xamDataGrid1);

myReport.Sections.Add(myXamDataGridReport);

Print Preview

The next thing that you can do is to actually send your printed document to a print preview dialog. Infragistics has created a control (XamReportPreview) to accomplish this. To use it, you can add the control to your WPF Application like this:

<Window x:Class="XamCommunitySample.MainWindow1"
…
        xmlns:igReports="http://infragistics.com/Reporting"
… >
…
    <igReports:XamReportPreview x:Name="xamReportPreview1" />
…
</Window>

//Method Signature GeneratePreview(Report, bool showPrintDialog, bool showReportProgressControl);
xamReportPreview1.GeneratePreview(myReport, false, true);

You can notice that we are using the xamReportPreview control’s GeneratePreview method and passing it the Report we just created. The method signature actually has a couple extra parameters that will help with the actual experience of the printing experience. The parameters are as follows:

Infragistics.Windows.Reports.Report – The Report that the developer wants to print/print preview
bool ShowPrintDialog – This shows the standard PrintPreviewDialog that enables the application’s consumer to configure the printer and print location.
bool ShowReportProgressControl – this is a helper that will generate a dialog that will give the application’s consumer a status on the status of the print preview being generated.

Printing

Lastly, there are two other methods that are core to the printing of a document; Export and Print. These two methods do essentially exactly what they describe send a document to the printer or export a document to XPS. The code do to do this looks something like this:

myReport.Print();

myReport.Export(Infragistics.Windows.Reporting.OutputFormat.XPS, 
  "FileLocation");

That’s it. With that small amount of code, you have successfully printed or exported your XamDataGrid or any Visual Element.

Tags: WPF, XamDataGrid, Infragistics.Reports

Defining a Custom Path in the XamCarousel

[Infragistics] Andrew Flick — Sat, 28 Feb 2009 11:29:08 GMT

Current Revision posted to WPF by [Infragistics] Andrew Flick on 2/28/2009 11:29:08 AM

Introduction

The XamCarousel line of controls brings the sizzle of WPF to the client developer. It makes it easy to create navigation views or data-bound contact rolodexes. This tutorial will demonstrate how to define a custom path upon which the carousel items will arrange themselves.

Creating a Custom Path

First step, is to define your custom path. This can be achieved by using the Pen Tool in Blend and having a little fun drawing. Essentially, what you are working on is getting the data from the path property and re-use it in your Carousel.

In XAML that path looks like this:

<Path x:Name="myPath"  Margin="0,0,0,0" HorizontalAlignment="Left" 
      VerticalAlignment="Top" Height="Auto" Width="Auto" Stretch="Fill" 
      Data="M8,210.04 C83.5,85.541096 177.5,84.54052 236.5,204.53999 295.5,
      324.54002 398.5,251.53956 409.5,210.53999 466.5,84.541153 561.5,88.54112 
      609.5,212.54011" 
      Stroke="#FF0000" StrokeThickness="1" />

Assigning the Custom Path to the Carousel

After the path is drawn, initialize one of the XamCarousel controls. In the case of this sample, we are going to add a custom path to our XamCarouselPanel which will host a series of images. The XAML code looks like this:

<igWindows:XamCarouselPanel Margin="0,0,0,0">
    <igWindows:XamCarouselPanel.ViewSettings>
          <igWindows:CarouselViewSettings IsListContinuous="True"/>
   </igWindows:XamCarouselPanel.ViewSettings>
   <Image Source="Images/Autumn Leaves.jpg" Width="130" />
   <Image Source="Images/Creek.jpg" Width="130" />
    …
</igWindows:XamCarouselPanel>

Next, we need to make a quick resource that will house our path definition. We can simply copy our above path into the <Grid.Resources> <Path x:key=”myPath”… /> </Grid.Resources> and assign a x:key name to the Path.

<igWindows:CarouselViewSettings IsListContinuous="True" 
           ItemPath="{StaticResource myPath}" ItemsPerPage=”7”/>

And that’s it, after that we have officially styled the xamCarousel to follow our custom path!

Tags: XamCarouselPanel, XamCarouseLlistbox, WPF, xamDataCarousel

Creating a Custom Summary for the XamDataGrid

[Infragistics] Andrew Flick — Sat, 28 Feb 2009 11:13:39 GMT

Current Revision posted to WPF by [Infragistics] Andrew Flick on 2/28/2009 11:13:39 AM

Introduction

The XamDataGrid Row Summary functionality allows for a lot of flexibility. It enables developers to easily expose basic summary information to their consumers with a simple property setting as demonstrated here. In some situations, a developer may want to either have more control over a summary result or create their own business specific formula.

This article will look at information stored in a DataGrid and given a particular sales person calculate who sold the most for a given year and then integrate that summary into the xamDataGrid.

Create a Custom Summary Class

To begin, create a custom class titled TopSalesPerson and add to that class two imports/using statements and inherit from SummaryCalculator:

using Infragistics.Windows.DataPresenter;
using Infragistics.Windows;
…
namespace XamCommunitySample
{     	
    class TopSalesPerson : SummaryCalculator
    {
        private string _currentTopSalesPerson;
  private double _currentTopSalesAmount;
    }
}

Next implement the BeginCalculation Method to initialize your variables:

public override void BeginCalculation(SummaryResult summaryResult)
{
   _currentTopSalesAmount = 0;
   _currentTopSalesPerson = string.Empty;
}

Next, implement the CanProcessDataType to tell the calculator to only calculate for numeric types:

public override bool CanProcessDataType(Type dataType)
{
   return Utilities.IsNumericType(dataType);
}

The next part deals with the core part of our custom business logic in the aggregate method. The aggregate method essentially loops over every record in the xamDataGrid and gives you access to that Record as well as to the value in the current calculating column for that particular record. For our sample, we’re going to keep tabs on the current sales leader in a given category and as we find a leader update our string with that person’s name.

public override void Aggregate(object dataValue, SummaryResult summaryResult, 
  Record record)
{
  double myCellValue = double.Parse(dataValue.ToString());
  DataRecord myCurrentRecord = record as DataRecord;

  if (myCellValue  > _currentTopSalesAmount)
  {
     _currentTopSalesAmount = myCellValue;
     _currentTopSalesPerson = 
      myCurrentRecord.Cells["FirstName"].Value.ToString() + " " +   
      myCurrentRecord.Cells["LastName"].Value.ToString();
    }
}

After we’ve implemented this method, we only have a couple of steps in our calculation class to go. The first one, is to return the Winning Sales Persons name. The second is to name our custom calculation function and give it a description. The name is what will display in the dropdown box at run-time in the datagrid.

public override object EndCalculation(SummaryResult summaryResult)
{
   return _currentTopSalesPerson;
}

public override string Name
{
   get { return "Sales Leader"; }
}

public override string Description
{
    get { return "Top Sales Person"; }
}

Link the Custom Summary to the Application

Almost finished, now we can assign our new custom summary to our application by inserting it into our window_loaded method:

private void Window_Loaded(object sender, RoutedEventArgs e)
{
   TopSalesPerson Summary = new TopSalesPerson();
   SummaryCalculator.Register(Summary);
}

Lastly, the developer may want to show their custom summary on a specific field without placing it on every column. For instance, we may have a Quota column and a Sales column; the end-user would expect to see who the top sales person was, but maybe not who had the highest quota. This can be achieved by not registering our summary like demonstrated above, but by associating a specific summary definition with a given column:

TopSalesPerson Summary = new TopSalesPerson();
     
SummaryDefinition myTopSalesPersonFormula = new SummaryDefinition();
myTopSalesPersonFormula.SourceFieldName = "SalesYTD";
myTopSalesPersonFormula.Calculator = Summary;
this.xamDataGrid1.FieldLayouts[0].SummaryDefinitions.Add(myTopSalesPersonFormula);

In closing, the summary capabilities of the DataPresenter off ease of use in the pre-built commonly used formulas and flexibility in the ability to quickly add custom formulas to the DataGrid.

Tags: WPF, XamDataGrid, Aggregation

Creating a Custom Summary for the XamDataGrid

[Infragistics] Andrew Flick — Sat, 28 Feb 2009 11:12:24 GMT

Revision 1 posted to WPF by [Infragistics] Andrew Flick on 2/28/2009 11:12:24 AM

Introduction

This article will look at information stored in a DataGrid and given a particular sales person calculate who sold the most for a given year and then integrate that summary into the xamDataGrid.

Create a Custom Summary Class

To begin, create a custom class titled TopSalesPerson and add to that class two imports/using statements and inherit from SummaryCalculator:

using Infragistics.Windows.DataPresenter;
using Infragistics.Windows;
…
namespace XamCommunitySample
{     	
    class TopSalesPerson : SummaryCalculator
    {
        private string _currentTopSalesPerson;
  private double _currentTopSalesAmount;
    }
}

Next implement the BeginCalculation Method to initialize your variables:

public override void BeginCalculation(SummaryResult summaryResult)
{
   _currentTopSalesAmount = 0;
   _currentTopSalesPerson = string.Empty;
}

Next, implement the CanProcessDataType to tell the calculator to only calculate for numeric types:

public override bool CanProcessDataType(Type dataType)
{
   return Utilities.IsNumericType(dataType);
}

public override void Aggregate(object dataValue, SummaryResult summaryResult, 
  Record record)
{
  double myCellValue = double.Parse(dataValue.ToString());
  DataRecord myCurrentRecord = record as DataRecord;

  if (myCellValue  > _currentTopSalesAmount)
  {
     _currentTopSalesAmount = myCellValue;
     _currentTopSalesPerson = 
      myCurrentRecord.Cells["FirstName"].Value.ToString() + " " +   
      myCurrentRecord.Cells["LastName"].Value.ToString();
    }
}

public override object EndCalculation(SummaryResult summaryResult)
{
   return _currentTopSalesPerson;
}

public override string Name
{
   get { return "Sales Leader"; }
}

public override string Description
{
    get { return "Top Sales Person"; }
}

Link the Custom Summary to the Application

Almost finished, now we can assign our new custom summary to our application by inserting it into our window_loaded method:

private void Window_Loaded(object sender, RoutedEventArgs e)
{
   TopSalesPerson Summary = new TopSalesPerson();
   SummaryCalculator.Register(Summary);
}

TopSalesPerson Summary = new TopSalesPerson();
     
SummaryDefinition myTopSalesPersonFormula = new SummaryDefinition();
myTopSalesPersonFormula.SourceFieldName = "SalesYTD";
myTopSalesPersonFormula.Calculator = Summary;
this.xamDataGrid1.FieldLayouts[0].SummaryDefinitions.Add(myTopSalesPersonFormula);

In closing, the summary capabilities of the DataPresenter off ease of use in the pre-built commonly used formulas and flexibility in the ability to quickly add custom formulas to the DataGrid.

Tags: WPF, XamDataGrid, Aggregation

Enabling Row Summaries in the XamDataGrid

[Infragistics] Andrew Flick — Sat, 28 Feb 2009 10:59:53 GMT

Current Revision posted to WPF by [Infragistics] Andrew Flick on 2/28/2009 10:59:53 AM

Introduction

Row Summaries or Row Aggregation is a feature that is enabled on the XamDataGrid quickly and easily by setting a couple of properties. The first property that needs to be set is the “AllowSummaries.” This property is off of the FieldSettings Object. By setting this property to true; the end user is now able to have a drop down button that shows a collection of standard summaries. (This is customizable and your own custom calculation could be added.)

<igDP:XamDataGrid x:Name="xamDataGrid1" DataSource="{Binding}">
  <igDP:XamDataGrid.FieldLayouts>
    <igDP:FieldLayout>
      <igDP:FieldLayout.FieldSettings>
        <igDP:FieldSettings AllowSummaries="True" SummaryUIType="Default" />    
      </igDP:FieldLayout.FieldSettings> 
    </igDP:FieldLayout>
  </igDP:XamDataGrid.FieldLayouts>
</igDP:XamDataGrid>

The next property of importance to the row summary capabilities is the SummaryUIType property. This property defines whether the end-user is able to select a single calculation or multiple (e.g. Count and Sum or only Count). The enumeration for this property has five values:

Multi-Select – User can select multiple calculations for all columns
Multi-Select for Numerics Only – User can select multiple calculations and no calculations on non-numeric based columns
Single-Select – User can only select a single calculation at a given time.
Single-Select for Numerics Only – User can only select a single calculation at a given time and no calculations on non-numeric based columns.
Default – Multi-Select for Numerics Only

The last core property for Row Summaries in the XamDataGrid is the SummaryDisplayArea property. This, like the name implies, controls how and where summaries are displayed. The enum for this property contains eight possibilities:

None – Summary is hidden
Top – Summary is displayed at the top of the XamDataGrid
TopFixed – Summary is displayed at the top of the XamDataGrid and does not move when the grid is scrolled.
Bottom – Summary is displayed at the bottom of the XamDataGrid
BottomFixed – Summary is displayed at the bottom of the XamDataGrid and stays in view when the grid is scrolled
TopLevelOnly – This option effects a group-by display scenario and will only show records for the top level record collection (By default summary records are displayed at all levels.)
DataRecordsOnly – Summary records are displayed for DataRecordsOnly. When the XamDataGrid is in groupby mode, the summary records are not displayed.
InGroupByRecords – Summaries are displayed in each of the group-by records.
Default – TopLevelOnly and InGroupByRecords

Lastly, all of the above properties can be set procedurally as follows:

using Infragistics.Windows.DataPresenter;
...
this.xamDataGrid1.FieldSettings.AllowSummaries = true;
this.xamDataGrid1.FieldSettings.SummaryUIType = SummaryUIType.MultiSelect;
this.xamDataGrid1.FieldSettings.SummaryDisplayArea =     
    SummaryDisplayAreas.InGroupByRecords | SummaryDisplayAreas.BottomFixed;
...

Tags: WPF, XamDataGrid, Aggregation

Exporting the XamDataGrid to Excel

[Infragistics] Andrew Flick — Sat, 28 Feb 2009 10:55:09 GMT

Current Revision posted to WPF by [Infragistics] Andrew Flick on 2/28/2009 10:55:09 AM

Infragistics.Excel is an extremely powerful, yet little known API. It has the capability to build an entire Excel Workbook (and multiple worksheets). You can add formulas and interact with an Excel document in C# code in many different fashions. On the roadmap for Infragistics WPF is to add support for a single method call to export the XamDataGrid to Excel; in the meantime, this code library gives you the basic functionality in a single class that you can easily re-use to achieve the exporting work.

Basically, the class loops through RecordsCollection (also checks for records in the GroupByRecordsCollection) and creates a Infragistics.Excel.WorkSheetRow for each record.

To consume this class, simply new up the exporter class and call the export method:

xamDataGridExcelExporter.xamDataGridExcelExporter xamDataGridExcelExporter1 =    
   new xamDataGridExcelExporter.xamDataGridExcelExporter();
xamDataGridExcelExporter1.Export(this.xamDataGrid1,
   @"C:\Excel\ExportFile.xls");

You can find the sample code here.

Tags: WPF, XamDataGrid, Excel

Configuring the XamTab Control

[Infragistics] Andrew Flick — Sat, 28 Feb 2009 10:51:37 GMT

Current Revision posted to WPF by [Infragistics] Andrew Flick on 2/28/2009 10:51:37 AM

Introduction

The XamTab Control was a control that was written in part to support the development of the XamRibbon. It supports a few additional features that will make it easy for a developer to create a familiar tabbed experience.

Setting up the Tab Control

To start, the developer should add the Infragistics3.Wpf dll to their project (or just drag the tab onto the design surface). The basic tab definition in xaml should look something like this:

<Window x:Class="XamCommunitySample.MainWindow1"  
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
    Title="Main Window Sample" Height="600" Width="800"  
        …   
        xmlns:igWindows="http://infragistics.com/Windows"  
         …   
>  
…   
  <igWindows:XamTabControl x:Name="xamTab1" Theme="Office2k7Blue">  
     <igWindows:TabItemEx Header="Tab1">  
         <!--Content-->  
     </igWindows:TabItemEx>  
     <igWindows:TabItemEx Header="Tab2">  
         <!--Content-->  
     </igWindows:TabItemEx>  
  </igWindows:XamTabControl>  
…   
</Window>

Customizing the Tab Control

Then you have the ability to customize the layout of the tab control; where tabs are placed, if they scroll, or are stacked, and the ability to close them.

To control where Tabs are placed you are given the option of positioning tabs on the top, left, bottom, or right of the content by setting the TabStripPlacement Property. You can also determine how the tabs are displayed in each of these locations by setting the TabLayoutStyle property to one of the following:

MultiRowAutoSize – Allows for multiple rows of tabs and sized based on their content
MultiRowSizeToFit – Allows for multiple rows of tabs and sized based on their content and then allowed to grow in size if more room to display the items is available.
SingleRowAutoSize – Allows for a single row of tab that is sized based on the size of the content.
SingleRowJustified – Allows for a single row of tabs that is sized first based on their content and then reduced in size if there is not enough room to fit the items.
SingleRowSizeToFit – Allows for a single row of tabs that is sized based on their content and then allowed to grow in size if more room to display the items is available.

To give the tab the ability to close, simply set the TabItemCloseButtonVisibility property. This property takes one of four different self-descriptive settings: hidden, visible, WhenSelected, and WhenSelectedOrHotTracked. All of the above settings can be set off the base Tab control like this:

<igWindows:XamTabControl x:Name="xamTab1" Theme="Office2k7Blue"    
           TabStripPlacement="Top" TabLayoutStyle="SingleRowSizeToFit"    
           TabItemCloseButtonVisibility="WhenSelectedOrHotTracked">

Lastly, another interesting feature about the tab control is the ability to have some sort of content injected in front of or following the tabs. This is useful for adding your own custom buttons or items that should span across multiple tabs. To do this simply insert some sort of content into either the PreTabItemContent or the PostTabItemContent like this:

<igWindows:XamTabControl.PostTabItemContent>  
  <StackPanel Orientation="Horizontal">  
     <Button Margin="0,0,0,0" Click="Button_Click">Print Content</Button>  
  </StackPanel>  
</igWindows:XamTabControl.PostTabItemContent>

The tab control with its additional styling capability by setting the theme property definitely gives you the ability to easily create the tabbed browsing experience popular in many current Windows Client application.

Tags: WPF, XamTab