Tom Puglisi

UltraMediaPlayer CAB Walkthrough

[Infragistics] Tom Puglisi — Wed, 11 Jul 2012 21:21:00 GMT

Hey everyone,

To help those people that are using Windows Forms and Microsoft CAB, I decided to clean up and update my "Ultra Media Player" Reference application and tell you all about it.

I created a video that walks you through the technical aspects of the application, as well as some aspects of Microsoft CAB (Composite UI Application Block), Infragistics CAB Utility Kit, as well as how you can make an awesome Media Player application using the time proven Infragistics Windows Forms controls ALONG WITH CAB!

Due to quite a few questions on Windows Forms, CAB, and the Infragistics Composite UI Application Block Extension kit, I felt that this reference app and walkthrough would be the best way to communicate things such as:

How the Infragistics CAB functionality is set up in the sample app (igFormShellApplication)
How Infragistics UI Elements (buttons, menu items, etc) are created in ONE module, then passed off to the SHELL without actually being any references
How to create and load Smart Parts into the awesome Infragistics Windows Forms based WorkSpaces such as the DockManager workspace, Tabbed MDI workspace, etc
How to use the CAB Event Broker to PUBLISH and SUBSCRIBE to events to update the UI across unreferenced assembly boundaries.
I also have an awesome Draw Filter (Infragistics Windows Forms's technique of hijacking the PAINTING of controls to do things YOUR way) that I created to achieve a load-on-demand strategy for accessing media files, extracting a video snapshot and loading it into the Infragistics WinListView control.

Please watch the video and download the sample application (links below). Review the code, comments, and enjoy!

Watch Video Here

Download Sample Application Here

Insert Dynamic Images in Infragistics Reporting

[Infragistics] Tom Puglisi — Wed, 01 Feb 2012 21:25:00 GMT

Infragistics Reporting is an awesome product that you can use to add reports to your applications. I know many of you have Windows Forms applications and are thinking of using the IG Reporting to quickly add a rich set of reports. I ALSO know that there are customers that have custom controls that they have invested TONS of time in creating, for example, custom scientific charts (wink!) and would LOVE to see them in the Infragistics Reports. Well, with the technique used in this article, you can do this, provided you can convert your custom control into an image. This technique takes advantage of the Infragistics Reporting product’s Image control’s ability to dynamically pick up images on the file system each time the report is generated. In this topic, I will use the Infragistics Windows Forms UltraWinChart as my “custom control that I want to add to the report”.

Download the sample here.

Logic

The execution logic is simple:

Convert your control into an image and save it to disk. The Infragistics UltraWinChart has a method for that, so it is easy.
Refresh your report
THAT’S IT!

        private void LoadData()
        {
            //Add dummy data to the chart control:
            this.ultraChart1.Data.DataSource = 
                Infragistics.UltraChart.Data.DemoTable.AllPositive();
            this.ultraChart1.Data.DataBind();

            //Dump an image of the chart control:
            this.ultraChart1.SaveTo(
                Application.StartupPath + @"\Images\A.jpg", 
                System.Drawing.Imaging.ImageFormat.Jpeg);

            //Render the report:
            this.ultraReportViewer1.RefreshReport();
        }

Project and Report Setup

That’s easy too. Add an Infragistics Reporting Image control to your report and set its ImageURL Property to a valid path and filename for your image. Remember, you will be generating that actual image and naming it as you have specified in the ImageURL Property, so keep that in mind.

That’s it! You can use this technique to dump ANY of your controls or anything else into an Image that will get picked up by the Infragistics Report at runtime!

WinGrid Runtime Config and Persistence

[Infragistics] Tom Puglisi — Thu, 26 Jan 2012 21:20:00 GMT

Ever wanted to create a WinForms app that uses WinGrid and expose the powerful control API to your end users so that they can totally customize columns, add formulas, style the look and feel, even add, remove and hide columns, or JUST ABOUT ANYTHING that you can typically do in Microsoft™ Visual Studio though the Property Window? Well, check out this blog post and you CAN!

In this sample (feel free to download it), I have the Infragistics NetAdvantage Windows Forms WinGrid control along with a Microsoft Property Grid control thrown onto the form. I am also using the NetAdvantage WinTilePanel control to allow you to move the various controls around the screen however you like. The Property Grid control is hooked up to the WinGrid control’s DisplayLayout property. The DisplayLayout property essentially contains ALL of the WinGrid control’s important property settings related to its functionality, behaviors, features, schema, and so forth.

With this kind of setup, you can run the application and then play around with the various property settings at runtime. However, the awesome part is:

With just a few lines of code, you can SAVE whatever changes you make to WinGrid and then LOAD them up later on. That’s the part that I LIKE

This is the form layout along with the controls:

The following code shows the simplicity of LOADING and SAVING this particular WinGrid control’s settings:

        string _settings = Application.StartupPath + @"\settings.xml";

        private void Form1_Load(object sender, EventArgs e)
        {
            //Load Settings
            if (File.Exists(_settings))
            {
                this.ultraGrid1.DisplayLayout.LoadFromXml(
                    _settings, 
                    Infragistics.Win.UltraWinGrid.PropertyCategories.All);
            }
            //Get Data
            this.ordersTableAdapter.Fill(this.nwindDataSet.Orders);
            this.order_DetailsTableAdapter1.Fill(this.nwindDataSet.Order_Details);
            
            //Set PropertyGrid to WinGrid's DisplayLayout property
            this.propertyGrid1.SelectedObject = this.ultraGrid1.DisplayLayout;
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            //Save Layout
            this.ultraGrid1.DisplayLayout.SaveAsXml(
                _settings, 
                Infragistics.Win.UltraWinGrid.PropertyCategories.All);
        }

When you download and run this sample, you can observe the various columns that have been added to the BAND[0].Columns collection as well as the BAND[1].Columns collection. I added two unbound columns and set their Formula property through the WinCalcManager component’s Formula Editor. That’s right! I also have the NetAdvantage WinCalcManager component thrown onto the form so that even at runtime, I can use the component’s ability to customize WinGrid by adding as many additional empty columns as I like, while setting the Column object’s Formula property to evaluate as many as 140 Excel-like functions that are at your disposal. You can also provide WinCalcManager-powered summaries that aggregate column data. As a matter of fact, the ROOT entity in WinGrid has an unbound column that actually displays the SUM of its child order item’s TOTAL column.

Try this: after playing around with the sample, DELETE the settings.xml file from the sample’s BIN folder. Now run it again. The WinGrid control will be reset. All of MY customizations that were saved are now blown away.

Now that you have seen this sample and got the idea of how it works, you can apply the same or similar concepts to your larger-scale apps as well. Remember that if you use the Microsoft Property Grid control, you may scare some of your end users, but you can carefully target just PARTS of the WinGrid object model in order to minimize your end users BREAKING stuff!

Enjoy!

Simple Microsoft™ CAB Sample

[Infragistics] Tom Puglisi — Thu, 19 Jan 2012 21:39:00 GMT

As I was digging through the ole’ code bucket, I found a sample that I made several years ago in order to communicate the Microsoft™ CAB (Composite UI Application Block) Architectural Framework. There have been a few customers asking me questions about MS CAB as of late, so I decided to post this sample and discuss it a tad.

This sample is a simple implementation of MS CAB; in other words, it does not use any of those Guidance Automation Toolkit scripts (SCSF – smart client software factory). This is just a plain, simple “reference the MS CAB assemblies, and write the entire code yourself by hand” kind of sample! This sample also does not implement the MVP (Model View Presenter) pattern, which is also a by-product of using SCSF. In this sample, there is actually CODE IN THE UI – GASP!

Again, this sample was created to show a very simple implementation of MS CAB and its core components, along with the Infragistics CAB Extensibility Kit that comes with your Infragistics NetAdvantage Windows Forms installation.

Feel free to download and review the code within this example.

The sample application comes in the form of a media player.

Project References

One of the most important things that make this a CAB application are the references. The three Microsoft.Practices.[XXXXX] assemblies contain the essential components that help execute, fire events, manage user controls (Smart Parts) and form elements (UIElements) through out your application’s execution cycle. The Microsoft CAB assemblies are located in a folder named “Lib” located within the main solution folder.

The Infragistics.CompositeUI.Winforms assembly reference represents the CAB Extensibility Kit library that extends several Infragistics controls to work just like CAB WorkSpaces as well as provide UIElement Support to other Infragistics controls.

Review of Projects

CabMediaPlayer – This contains the “shell” or main, empty user interface. The Shell will be populated by other, more functional user controls (Smart Parts) that exist within the other Projects. The Shell also contains controls that are designed to accept buttons, menu items, or other “UIElements” that are defined and contained within the other Projects.
MediaContentAddin, PlaylistAddin, WindowsMediaPlayerAddin – These projects can be considered “add-ins” or “plug-ins” that automatically expose their designated functionality at runtime, through the help of the CAB runtime, to the main Shell. Each of these add-ins contain functionality, Smart Parts, and UIElements that fit into the main Shell so that you can see and interact with these functionalities.
MediaPlayerCommon – This is a project that contains code common to all add-ins, therefore referenced by the add-ins.
Infragistics Project – This is the Infragistics CAB project. This is included within the Visual Studio Solution so that upgrading NetAdvantage volume versions is easy and performed all in one place. If you just reference the compiled assembly, you would need to upgrade this stand-alone project wherever it resides and then manually update everything that references this with your new assembly build. This project also comes with the Infragistics Windows Forms installation.

ALL projects reference the Infragistics and Microsoft CAB related assemblies.

The add-in projects reference the MediaPlayerCommon project.

The Shell project (CabMediaPlayer) does NOT have any references to any of the add-in projects. The add-ins are loaded at runtime by CAB through references noted in the ProfileCatalog.xml file located in the Shell project (CabMediaPlayer).

So, download this sample, run it and load up some media files. Double click the media items in the playlist to play them and observe what happens through out the UI. Afterwards, go through the various projects to see the actual parts of the CAB implementation (Dependency Injection, Events, UIElements, Smart Parts, WorkSpaces, etc) in a simplified form. Enjoy!

WPF Data Chart to PDF

[Infragistics] Tom Puglisi — Mon, 16 Jan 2012 16:05:00 GMT

The Infragistics NetAdvantage WPF controls toolset currently does not have a PDF engine, however, for certain cases, one can use the PDF engine available in the NetAdvantage Windows Forms toolset. In this topic, I will give you a quick explanation on how to accomplish this by taking an image snapshot of a WPF FrameworkElement and adding it to the PDF. I also include a simple downloadable sample.

Getting Started

Create a basic WPF Application that contains a Window along with an instance of xamDataChart. The xamDataChart control is set up with some data along with any combination of series, axes, legends, or whatever you need. For directions on how to get to this point, you can refer to the following xamDataChart getting started help topic.

References

Add the following references to your Microsoft™ Visual Studio project:

Infragistics4.Documents.Core.v11.2
Infragistics4.Documents.Reports.v11.2

The “4” in the first assembly naming section represents “CLR4”, and the “11.2” in the assembly name represents “the 2011, volume two version of the NetAdvantage product”.

These assemblies are part of the NetAdvantage Windows Forms installation.

Execution Logic

This is straight forward – convert a FrameWork element into an image; in this case, the xamDataChart control instance. Create a PDF Document and then insert the image into the PDF document. That’s it.

Image from FrameworkElement

The following C# code accomplishes this:

        public static void SaveImage(string fileName, FrameworkElement element)
        {
            string imageExtension = 
                new FileInfo(fileName).Extension.ToLower(CultureInfo.InvariantCulture);

            BitmapEncoder imgEncoder = null;
            switch (imageExtension)
            {
                case ".bmp":
                    imgEncoder = new BmpBitmapEncoder();
                    break;

                case ".jpg":
                case ".jpeg":
                    imgEncoder = new JpegBitmapEncoder();
                    break;

                case ".png":
                    imgEncoder = new PngBitmapEncoder();
                    break;

                case ".gif":
                    imgEncoder = new GifBitmapEncoder();
                    break;

                case ".tif":
                case ".tiff":
                    imgEncoder = new TiffBitmapEncoder();
                    break;

                case ".wdp":
                    imgEncoder = new WmpBitmapEncoder();
                    break;

                default:
                    imgEncoder = new BmpBitmapEncoder();
                    break;
            }

            if (element != null)
            {
                RenderTargetBitmap bmpSource = 
                    new RenderTargetBitmap(
                        (int)element.ActualWidth, 
                        (int)element.ActualHeight, 96, 96, 
                        PixelFormats.Pbgra32);
                bmpSource.Render(element);

                imgEncoder.Frames.Add(BitmapFrame.Create(bmpSource));
                using (Stream stream = File.Create(fileName))
                {
                    imgEncoder.Save(stream);
                    stream.Close();
                }
            }
        }

Creating a PDF Document

The following code creates a PDF document and includes the image generated from the previous code block.

        private void button1_Click(object sender, RoutedEventArgs e)
        {
            Report theReport = new Report();

            ISection theSection = theReport.AddSection();

            IText theText = theSection.AddText();

            theText.AddContent("Chart Data");

            string theImgFile = 
                AppDomain.CurrentDomain.BaseDirectory + @"\theimg.png";


            SaveImage(theImgFile, this.xamDataChart1);

            theSection.AddImage(
                new Infragistics.Documents.Reports.Graphics.Image(theImgFile));


            string theFile = AppDomain.CurrentDomain.BaseDirectory + @"\thePDF.pdf";

            theReport.Publish(theFile, FileFormat.PDF);

            System.Diagnostics.Process.Start(theFile);

        }

And there you have it, a simple way to convert a FrameworkElement into an Image and then load it into a PDF Document. One thing to note – this is a WYSIWYG approach – meaning that Whatever state the FrameworkElement is in,(xamDataChart control in this case) the image will be captured in that exact same state.

Feel free to download the included sample application.

NetAdvantage Reporting in Windows Forms

[Infragistics] Tom Puglisi — Tue, 29 Nov 2011 19:56:00 GMT

So you want to add reporting capabilities to your Windows Forms applications, how is this done? By using the new Infragistics NetAdvantage Reporting product, you can now create and add reports to your Windows Forms applications easily!

In this topic, I will show Windows Forms developers how to create a new report in Microsoft™ Visual Studio™ using the Infragistics NetAdvantage Reporting product and then display your report in a Windows Form.

Getting Started

Create a NEW Windows Forms project named “NetAdvantage_Reporting_in_WinForms”. Add a new folder to your project named “Reports”.

Double-click on Form1 and get it into design mode. You will add two Infragistics Windows Forms controls to it. In your Visual Studio toolbox, locate the Infragistics NetAdvantage 11.2 toolbox tab and in this tab, drag and drop the UltraComboEditor control onto your form. Set its Dock property to “Top”. Then locate the NetAdvantage Reporting Windows Forms toolbox tab and then drag and drop the UltraReportViewer control onto your form and set its Dock property to “Fill”. Everything should look like this so far:

Creating a Simple Report

To create a new report, locate and right-click the Reporting folder you created earlier and select “Add New Item”.

In the Add New Item dialog, Locate the Infragistics node, expand it and select Reporting. You will then select the “Infragistics Report” item from the list of various Infragistics Reporting items.

Name the report “Product_Listing".igr” and click ADD.

Design the Report

To design the content of the report, double click the Infragistics Report you just added to your project. You can now design the report using the intuitive Infragistics design-time user interface. We will keep things simple in this topic, so to start designing the report, click the Add “A Report Data Source…” icon located in the center of your report that is shown in design mode. You can navigate to an instance of the Microsoft™ Northwind™ database sample that you should have running somewhere that is accessible. Select the Products table for this particular report. Locate the Report Data Explorer tab in Visual Studio and bring it into view. You are now ready to select data to show on your report.

In the Report Data Explorer, locate and control+click the following three fields:

ProductName
UnitPrice
UnitsInStock

With these three fields selected, drag and drop them as one unit onto the center of the Report Body. This is how you define which data fields will be presented in the Report Body. You can feel free to experiment setting properties on the various items that were just generated. For example, select the entire Header row in the Table that was just created and then set its background color to a color of your choice.

Let’s create a Title for this report by finding the Visual Studio Toolbox, locating the NetAdvantage Reporting toolbox tab and then drag and drop a Label control onto the Page Header portion of the report. This is located towards the top of the report in design mode. Change the Text to “Northwind Product Listing” and then change the Label’s Font size to 30. Feel free to experiment with other properties such as color and alignment.

Make sure your report works by clicking the Preview button located on your report in Design Mode:

Show the Report

Now it is time to show your report to your end users. Before moving onto the next step, you can feel free to create more reports using the same technique that you just learned in the previous steps. Create a few more reports that pull data from other data sources you may have available and add them to the Reports folder in this project.

Note: I have two reports in this project, one named Northwind_Customer_Listing.igr and the other named Product_Listing.igr.

Write the following code in the Form_Load event:

 private void Form1_Load(object sender, EventArgs e)
        {
            this.cboReportList.Items.Add("Northwind_Customer_Listing");
            this.cboReportList.Items.Add("Product_Listing");
        }

Next, handle the UltraComboEditor control’s ValueChanged event and add the following code to that event:

private void cboReportList_ValueChanged(object sender, EventArgs e)
{
            string reportMain = 
             "/NetAdvantage_Reporting_in_WinForms;component/Reports/{0}.igr";
            
           this.ultraReportViewer1.RenderSettings.DefinitionUri = 
                new System.Uri(
                    string.Format(reportMain, 
                    this.cboReportList.Value.ToString() ), 
                    System.UriKind.Relative);
}

Run the App

That’s it! Now run the application and select a report from the UltraComboEditor control. The report that you selected should automatically load in the UltraReportViewer control. You can also zoom in and out, export, and navigate the entirety of this report.

This is all that is needed to add reporting to your Windows Forms applications using the Infragistics NetAdvantage Reporting product!

Taking it to the next level

I showed you how to create and display simple reports in a simple application. As you learn how to take advantage of more advanced reporting capabilities, you can create more compelling reports with charts, filter parameters, and many more features such as grouping, summaries, and aggregate functions. You can also come up with a more elegant report title navigation user interface that allows your end users to navigate, select, and display reports. Think of other Infragisics NetAdvantage Windows Forms controls that you could use such as the UltraExplorerBar, UltraDockManager, and UltraTree. The rest is up to you to make it happen!

WinGrid Dropdown Column to Excel Dropdown List

[Infragistics] Tom Puglisi — Tue, 22 Nov 2011 18:41:00 GMT

Ever wanted to export your WinGrid to a Microsoft™ Excel™ file complete with your dropdown columns intact so that your end users could select items from the same list in Excel? Well with the new Infragistics Excel Library ListDataValidationRule feature, part of the Excel Data Validation feature set, YOU CAN!

How this is done:

The sample application contains a WinGrid control bound to the Products table in the Northwind database. The WinGrid’s CategoryID column is wired up to the WinDropdown control, which essentially provides a dropdown list of values for the CategoryID column. The WinDropdown control is bound to the Category table in the Northwind database.

End users can change the value of the CategoryID column by picking from the list of values available from the WinDropdown control.

We use the WinGridExcelExporter component to easily export WinGrid into an Excel file.

The goal of this blog post is to provide our end users with the same experience within the Excel file that we export with WinGridExcelExporter – a dropdown list of values on the CategoryID column so that end users can pick from the same list of values available in WinGrid.

The following class wraps up the logic used to create a ListValidationRule object and apply it to each WorkBookCell object.

view plain copy to clipboard print

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Infragistics.Documents.Excel;
using Infragistics.Win.UltraWinGrid.ExcelExport;
namespace NewExcelFeatures
{
public class ExcelListConverter
{
private UltraGridExcelExporter _theExcelExporter;
private string _theItemsListString;
private string _theColumnName;
private Dictionary<int, string> CellReferenceDictionary = new Dictionary<int, string>();
public ExcelListConverter(UltraGridExcelExporter theExcelExporter, string theItemsListString, string theColumnName)
{
_theExcelExporter = theExcelExporter;
_theItemsListString = theItemsListString;
_theColumnName = theColumnName;
_theExcelExporter.CellExported += new CellExportedEventHandler(_theExcelExporter_CellExported);
//Used to convert a column index into an Excel Cell Column Address Reference Character
CellReferenceDictionary.Add(0, "A");
CellReferenceDictionary.Add(1, "B");
CellReferenceDictionary.Add(2, "C");
CellReferenceDictionary.Add(3, "D");
CellReferenceDictionary.Add(4, "E");
CellReferenceDictionary.Add(5, "F");
CellReferenceDictionary.Add(6, "G");
CellReferenceDictionary.Add(7, "H");
CellReferenceDictionary.Add(8, "I");
}
/// <summary>
/// While each cell is exported, we add a list validation rule to the appropriate Excel Column
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void _theExcelExporter_CellExported(object sender, Infragistics.Win.UltraWinGrid.ExcelExport.CellExportedEventArgs e)
{
if (e.GridColumn.Key == _theColumnName)
{
WorksheetCell c = e.CurrentWorksheet.Rows[e.CurrentRowIndex].Cells[e.CurrentColumnIndex] as WorksheetCell;
string currentRowIndex = (e.CurrentRowIndex + 1).ToString();
this.SetListValidationRule(e.CurrentWorksheet, _theItemsListString, CellReferenceDictionary[e.CurrentColumnIndex] + currentRowIndex);
}
}
private void SetListValidationRule(Worksheet theWorksheet, string theListItems, string theCellAddress)
{
// Create a variable for the base data validation rule
DataValidationRule dataRule = null;
// Create a variable for the worksheet reference collection
WorksheetReferenceCollection cellCollection = null;
// Create a new list data validation rule
ListDataValidationRule ld = new ListDataValidationRule();
// Copy the validation rule reference to the base data rule variable
dataRule = ld;
// Allow the worksheet cell to contain null values
ld.AllowNull = true;
// Allow the showing of the drop down for valid cell values
ld.ShowDropdown = true;
// Set the cell's valid values
string theListOfItemsExcelString = string.Format("=\"{0}\"", theListItems);
ld.SetValuesFormula(theListOfItemsExcelString, theCellAddress);
// Reference the worksheet cell in the collection
cellCollection = new WorksheetReferenceCollection(theWorksheet, theCellAddress);
// Add the error message information
dataRule.ErrorMessageDescription = "Invalid value entered.";
dataRule.ErrorMessageTitle = "Validation Error";
dataRule.ErrorStyle = DataValidationErrorStyle.Stop;
// Add the input message information
dataRule.InputMessageDescription = "Type or select a value from the list.";
dataRule.InputMessageTitle = "Value Selection";
// Set whether or not to display the error message after an invalid value was entered
dataRule.ShowErrorMessageForInvalidValue = true;
// Set whether or not to display the input message
dataRule.ShowInputMessage = true;
// Add the data validation to the worksheet
theWorksheet.DataValidationRules.Add(dataRule, cellCollection);
}
}
}

A simple example of using this class is shown here, in the button_click event handler found on the application’s main form:

view plain copy to clipboard print

private void btnExport_Click(object sender, EventArgs e)
{
string validationList = string.Empty;
//create a comma delimited list of values (no crazy chars allowed!)
foreach (DataRow d in this.nwindDataSet.Categories.Rows)
{
validationList += d["CategoryName"].ToString() + ",";
}
validationList = validationList.TrimEnd(new char[] { ',' });
ExcelListConverter c = new ExcelListConverter(this.ultraGridExcelExporter1, validationList, "CategoryID");
string theFile = Application.StartupPath + @"\theFile.xls";
this.ultraGridExcelExporter1.Export(this.ultraGrid1, theFile);
System.Diagnostics.Process.Start(theFile);
c = null;
}

Now your end users can select from the same list of items in your newly generated Excel file!

You can download the sample application attached to this blog post.

WinGrid Repetitive Paste

[Infragistics] Tom Puglisi — Mon, 14 Nov 2011 14:14:00 GMT

Ever try to mimic Microsoft™ Excel™ features in your WinGrid powered application? Well now as of NetAdvantage 2011.2 volume release, there is one more feature added to WinGrid that you can just implement by the use of a property. This is called WinGrid Repetitive Paste.

Typically when you copy a selection in WinGrid into your clipboard (learn more about WinGrid Clipboard Operations), you can paste the selection to a destination of the same size. With the new WinGrid Repetitive Paste feature, you can now select a region that is LARGER than the original selection and your paste will duplicate across the larger selection. The target destination must be a multiple of the original selection so that the paste can repeat completely each time.

So how do you take advantage of this new feature? Easy, follow these steps:

Enable clipboard operations by assigning any one or any combination of enumeration bit mask values to the following WinGrid property:
view plain copy to clipboard print
1. this.ultraGrid1.DisplayLayout.Override.AllowMultiCellOperations = AllowMultiCellOperation.All;
Run your WinGrid application and select one data cell.
Press the keyboard combination Control + C
Create a destination selection on WinGrid. Since we copied only one cell, we can paste to a target of many cells. If we copied more than one cell (E.g., 2), then we would have to create a target selection that is a multiple of that selection (E.g., 2, 4, 6, etc).
Press keyboard combination Control + V
That’s it! This is how you set up and enable WinGrid Repetitive Paste!

Updated Excel-Style Filtering in WinGrid

[Infragistics] Tom Puglisi — Mon, 14 Nov 2011 14:13:00 GMT

Infragistics has enhanced and updated the Microsoft™ Excel™-style filtering available in WinGrid in previous releases. Whenever enabling Excel-style filtering in WinGrid, you can filter WinGrid rows through a familiar Excel-style filter user interface as shown here:

With this kind of filter user interface, end users can check the items that they wish to display in WinGrid.

When no filter is applied, each column header contains a distinct list of values that you can filter on. These distinct values are loaded into the Excel-style filter UI.

New in the Infragistics NetAdvantage 2011.2 volume release, the Excel-style filtering behavior has been enhanced as follows:

Whenever you apply a filter to any WinGrid column such as we have done here:

…causes the remaining Excel-style filter UI dropdowns in the remaining columns to also be reduced to only contain the remaining items in their respective columns after the other column filter is applied:

This enhancement definitely improves upon the Excel-style filtering capabilities that exist on WinGrid.

“Asyncify” Your WinGrid Exports!

[Infragistics] Tom Puglisi — Mon, 14 Nov 2011 14:10:00 GMT

So you have a WinGrid powered application that contains exporting capabilities. This app was very easy to set up so that with the click of a button you can export to Microsoft™ Excel™, Microsoft™ Word™, PDF, or XPS formats. How do you make such awesome functionality even “Awesomer"? By adding the ability to export to these existing formats in an asynchronous fashion!

WinGrid Excel Exporting Async!

Why is this better? Whenever performing any code operation that is part of the user interface thread, your UI will “freeze” or not respond until the operation completes. If you can convert any of these operations to execute outside of the UI thread, your end-user experience can be improved. This does not mean it will be faster, however it means that the perceived performance and application responsiveness will be greatly improved. Bonus points if you even provide your end user with the ability to cancel a currently running operation.

Well, Infragistics has done it again! They have added an incredible feature to their exporting components so that you can choose to export in an asynchronous fashion just by calling the “async” version of the export method! The following exporting components have been given Asynchronous exporting capabilities:

WinGridExcelExporter
WinGridDocumentExporter
WinGridWordWriter

Consider the following simple pattern used to generate a file and then open it. This could be executed at the least from a Button_Click event handler:

view plain copy to clipboard print

_theFile = Application.StartupPath + @"\theFile.xlsx";
this.ultraGridExcelExporter1.Export(this.customersUltraGrid, _theFile);
System.Diagnostics.Process.Start(_theFile);

Converting this into an asynchronous operation requires a small change. First we must remove the Process.Start( ) out of this code block. Although this code has worked in my applications for many years and still exists in many production apps, there is a better place to relocate the Process.Start( ) line of code:

view plain copy to clipboard print

private void ultraGridExcelExporter1_ExportEnded(
object sender, Infragistics.Win.UltraWinGrid.ExcelExport.ExportEndedEventArgs e)
{
System.Diagnostics.Process.Start(_theFile);
}

The exporting component, in this case WinGridExcelExporter has an “Export Ended” event. This is going to fire for sure whenever the export has completed.

Also note that I use a class scoped string variable that represents the file name. I used to also declare, set a value, and then use a local string variable to create the file name. If you too are employing that pattern, you should also move it up into a class-scoped variable as I am doing here. My sample code here also uses a silly, hard-coded value; a production application will generate a more elegant file name OR leave it up to your end user with a file save dialog.

The next change to make this operation asynchronous is to call the ExportAsync( ) method from the exporting component:

view plain copy to clipboard print

this.ultraGridExcelExporter1.ExportAsync(this.customersUltraGrid, _theFile);

Now there is just one more thing that depends on how your application is designed. To sum up the next step:

DO NOT TOUCH THE GRID WHILE EXPORTING :)

WinGrid and WinGridExcelExporter provide a progress indicator as well as an overlay so that you cannot physically click or interact with the grid. You can even cancel the export process through this intrinsic UI that was built into WinGrid. However, my warning is targeted to those situations where you have OTHER user interface controls that when clicked could be invoking methods on WinGrid. If you do, then you should disable those controls BEFORE the export and enable them AFTER the export.

There you go, this is the info you basically need to convert your synchronous export to an asynchronous export!

Summary

Code to export async:

view plain copy to clipboard print

private void toolStripButton1_Click(object sender, EventArgs e)
{
//You can also put in code to disable those controls that interact with WinGrid
_theFile = Application.StartupPath + @"\theFile.xlsx";
this.ultraGridExcelExporter1.ExportAsync(this.customersUltraGrid, _theFile);
}
private void ultraGridExcelExporter1_ExportEnded(
object sender, Infragistics.Win.UltraWinGrid.ExcelExport.ExportEndedEventArgs e)
{
System.Diagnostics.Process.Start(_theFile);
//If you disabled any UI controls that interact with WinGrid, enable them HERE.
}

Docs on Upgrading to the new XAML controls

[Infragistics] Tom Puglisi — Wed, 16 Jun 2010 13:55:00 GMT

Intro

As you may have heard, Infragistics made some great changes to evolve and merge our XAML-based product's code base so that you can easily port code from your NetAdvantage-powered Silverlight application to a NetAdvantage-powered WPF application and vise-versa. To understand the technical details behind this change, make sure you read Devin Rader's blog post.

The purpose of my blog post is to ensure that you know about some topics in our documentation that will help you through the process of upgrading to the latest 10.2 version of NetAdvantage XAML based products.

Project Version Utility

If you want a tool that will automatically upgrade your project(s), update your namespaces, class names, references, and any other work that needs to be done in order for the upgrade to succeed, you can use the Project Version Utility - a utility that ships with the 10.2 version of ALL NetAdvantage products. For documentation on how to use the Project Version Utility, please check out the following documentation:

Using the Project Version Utility

You can also perform the upgrade manually by following this topic.

If you ever wanted to back out of the upgrade, this topic explains how to do this as well.

Assembly Namespace Changes

If you want to know the details of all assembly, namespace, class, and member changes, check out the following documentation:

NetAdvantage Silverlight 10.2 Assembly Rename and Refactoring

ASP.NET Aikido Controls Client-Side Object Model Code Snippets

[Infragistics] Tom Puglisi — Fri, 21 May 2010 18:54:00 GMT

Today is the official anniversary of the PacMan video game from the 80s. Google has done a great job of adding a browser embedded version of the game. After you have spent some time advancing several levels you may feel guilty that you have not been so productive. In order to compensate for the time you have spent playing PacMan, I have something that will allow you to redeem yourself and increase your knowledge of the Infragistics NetAdvantage ASP.NET Aikido controls’ client-side object model (CSOM). With this knowledge, you will be more productive, you will be able to design and architect your application more elegantly by handling client-side events, and interacting with the control’s client-side instance directly.

Client-Side Events
The NetAdvantage ASP.NET Aikido controls have many server-side string properties that actually represent client-side events. These string properties are assigned the name of the JavaScript function that gets invoked whenever a certain control event takes place on the client. These server-side properties that represent client-side events are well documented in the API guide by containing examples of the event and how to use the event arguments. The following information explains how to get to this information:

Start by going to the NetAdvantage ASP.NET online help:
http://help.infragistics.com/NetAdvantage/ASPNET/2010.1/CLR3.5/
In the Table of Contents (TOC) locate and expand the API Reference Guide
Locate and expand the Infragistics.Web assembly TOC node:
Locate and expand the Infragistics.Web.UI.ListControls Namespace TOC node
Locate and expand the WebDropDown TOC node. We will use WebDropDown as the example. Locate and expand the Properties TOC node:
Now locate and click the ClientEvents property TOC node:
The ClientEvents API topic shows the type that represents the WebDropDown control’s ClientEvents property. You can see that this property is of type DropDownClientEvents. Click the link to the DropDownClientEvents API documentation:
This takes you to the DropDownClientEvents Class API Documentation. In this topic, click the link to the DropDownClientEvents Members topic:
This takes you to the class member documentation. In this topic you will find server-side string properties that actually represent various client-side events associated with WebDropDown. Click on the ActivationChanged link:
This takes you to your end-point; the example JavaScript code for how to wire up the event (using C# or VB.NET code in your code-behind) as well as the JavaScript function signature and example code for interacting with the event arguments and the control all using client-side JavaScript.

Using this logic, you can get to lots of CSOM documentation that shows how to leverage more of the Aikido framework based NetAdvantage ASP.NET controls.

Introducing NetAdvantage Help for Microsoft Visual Studio 2010

[Infragistics] Tom Puglisi — Wed, 05 May 2010 13:37:00 GMT

Infragistics is proud to announce the new NetAdvantage help for the Microsoft™ Visual Studio™ 2010 platform. The NetAdvantage docs that you have been using to help you through your development are now available for the new Visual Studio 2010 IDE. You can download the NetAdvantage Visual Studio help through the My IG > Keys & Downloads section of our site:

Since this is a new version of the Microsoft help platform, there are a few known issues that are expected to be resolved. You can check out these known issues in this blog post:

http://blogs.infragistics.com/blogs/tom_puglisi/archive/2010/05/04/infragistics-netadvantage-visual-studio-2010-help-issues.aspx

Attention Windows Forms and ASP.NET Developers:

Additional steps are required to successfully install and register the NetAdvantage help for Visual Studio 2010. Please read this blog post to learn how to install the Visual Studio 2010 help for NetAdvantage Windows Forms and ASP.NET:

http://blogs.infragistics.com/blogs/tom_puglisi/archive/2010/05/04/installing-visual-studio-2010-help-for-netadvantage-windows-forms-and-asp-net-products.aspx

If you wish to uninstall the Visual Studio 2010 help for NetAdvantage Windows Forms and ASP.NET, read this blog post to learn how to do so:

http://blogs.infragistics.com/blogs/tom_puglisi/archive/2010/05/04/uninstalling-netadvantage-windows-forms-and-asp-net-visual-studio-2010-help.aspx

We are here to ensure your successful use of our new NetAdvantage help for Visual Studio 2010. If you experience any issues or need any assistance, we are more than happy to help! Please send us an email:

helpfeedback@infragistics.com

Thank you!

Infragistics NetAdvantage Visual Studio 2010 Help Issues

[Infragistics] Tom Puglisi — Tue, 04 May 2010 20:24:00 GMT

VS2010 Help Issues

The new Microsoft Visual Studio 2010 Help system is built upon a completely new system. The Visual Studio 2010 IDE ships with the first version of the new help system. There are several known issues in the help system that results in a less than optimal experience when viewing Infragistics NetAdvantage help content. We are attempting to resolve these issues by a combination of workarounds as well as waiting for fixes to be made to this first iteration of the Microsoft help system.
This topic outlines some of these known issues.

No Horizontal Scrolling

The new Microsoft help system renders content into a user interface assembled with HTML. Within this user interface, you do not have the ability to scroll content horizontally. Because of this change in user interface design, any content that exists within <pre> tags combined with line breaks no longer wraps into the viewable area of the user interface. In certain cases, code does not wrap into view, nor can you scroll horizontally to view it. The workaround is to double-click the line of code to select it, then copy and paste the content into a text editor. As another workaround, if you have two monitors, you can move the help viewer to your left monitor, then resize the window so that it extends to the right monitor.

Code Shredding

Line Breaks and Non-breaking spaces within code blocks that worked in the previous help system no longer work the same in the new help system. Any code content within <pre> tags that contains multiple non-breaking spaces or line breaks is subject to this issue. This problem is more apparent with markup based code.

Microsoft plans on shipping an updated version of the help software that addresses this issue.

The workaround is to use the code coloring scheme to differentiate between code and comments.

Installing on non en-US versions of Visual Studio 2010

You may experience issues when installing the NetAdvantage Visual Studio 2010 help on non en-US versions of Visual Studio. In some cases, the installation may be successful, however you may not be able to load any of the NetAdvantage content. If this happens, you can try to manually register the help files as described in this blog post:
Follow steps #4 and up
http://blogs.infragistics.com/blogs/tom_puglisi/archive/2010/05/04/installing-visual-studio-2010-help-for-netadvantage-windows-forms-and-asp-net-products.aspx

Additional end-user experience changes

Microsoft has also designed a new end-user experience for navigating and searching through the help. The following items describe some of these changes:

Table of Contents (TOC)
In previous versions of the installed help, the TOC was an interactive, infinitely expandable tree-like node structure that represents all topics and sub-topics. The new experience is slightly different. The new TOC represents the current topic’s sibling nodes as well as the current topic’s child nodes. The new TOC browsing experience will be to click on TOC nodes and then view the child topics. You then click on the child topics that interest you and then further drill down by continuously clicking. You cannot expand other sibling nodes simultaneously. You must navigate back to the higher level TOC nodes and then drill down through the sibling child nodes. This new design is to promote a positive low-bandwidth usage experience. This new design is also intended to promote an increased usage of the help system’s search functionality, where the end-user types in search criteria and performs a search rather than navigating and discovering content through the TOC.

Search Results
Search results cannot be filtered as was possible in the previous help system. When reviewing search results, you will essentially page through as many results as needed until you locate the topic that you are interested in. It is also possible that your search results will contain content from multiple libraries (E.g., Microsoft content, Infragistics content, etc).

Search Index
The new help system currently does not have a keyword index. In the previous help version, you can type in a few letters of what you believe to be the search criteria and immediately, you can see a list of keywords that are similar to your text. This functionality currently does not exist in the new help system. In the new help system, you type in the search criteria and then press the Search button.

Help Library Agent
The new help system is hosted by a local service that serves up help content via a mini web server. This service must be running when using the new help system. In most cases, the service will be launched when you view help content through Visual Studio or through the start menu shortcut to the Infragistics NetAdvantage help.

Uninstalling NetAdvantage Windows Forms and ASP.NET Visual Studio 2010 Help

[Infragistics] Tom Puglisi — Tue, 04 May 2010 20:15:00 GMT

This topic will show you how to uninstall Infragistics NetAdvantage Windows Forms and ASP.NET Help content from your Microsoft Visual Studio Help system.

1. Launch the Visual Studio Help Library Manager

2. In the Help Library Manager dialog, click the Remove Content link

3. Locate the Help library that you wish to remove and click its Remove link

4. Click the Remove button towards the bottom of the dialog window

5. The Help removal process may take a few moments to complete

6. When the process is complete, click the Finish button

7. Go to your operating system’s Control Panel and launch the Add/Remove Programs dialog

8. Locate and uninstall the NetAdvantage Help that you wish to remove

9. This completes the removal of the NetAdvantage Help files from your computer