Q1 2010 release focuses on strengthening 3 main aspects of RadControls for Silverlight and RadControls for WPF:

• Ensuring first-class performance for all data-centric controls through various techniques,
• Enhancing and polishing RadControls themes
• Providing highly advanced, enterprise-level features, especially for the data visualization controls 

We know that performance is crucial for line-of-business applications. Therefore, we always make sure that RadControls can help you achieve unmatched performance and this has always been our number one priority. RadControls achieve unbeatable performance through UI and Data Virtualization, Data Sampling and built-in Load On Demand features.

Several of the major controls in the bundles have been enhanced with UI virtualization support – Scheduler, CoverFlow and Book.

As a part of Q1 2010 we also want to bring an unparalleled visual richness to your applications. To achieve that we have done a major rework of all our themes. We used a uniform templating approach across all controls, streamlined naming conventions for resources and delivered a much more consistent look of the controls along the way.

RadControls for WPF bundle has been enriched with two new controls – Map and Book.

 

Another new control has been included in the Q1 2010 release. However, it continues to be in a CTP stage. This is the Transition control. We decided that this is the better way to proceed as we will need some more input from our community on how exactly to develop this control further. Therefore, we will be regularly blogging on the development progress so that we can clearly indicate the direction, in which the control is evolving and gather your feedback on whether this is the best direction.

Our Charting controls for Silverilght and WPF have been advanced with major new features such as Data Sampling, Zooming and Scrolling, Automatic SmartLables positioning, Sorting and Filtering and many more.

The new built-in paging of the GridView control now allows you to page through your data, thus resulting in an event faster and more responsive grid that can easily handle enormously large datasets.

The new major Q1 2010 release of RadControls for ASP.NET AJAX has just been uploaded on telerik.com. I know that there are many people who would like to download and try out the new controls/features in the release without any further delay, that is why I will spare you the details for now and will let you enjoy it at your own disposal :) The links below will direct you to the main resources that highlight the important parts you would like to take a look at:

 

What's new:
http://www.telerik.com/products/aspnet-ajax/whats-new.aspx

Release notes:
http://www.telerik.com/products/aspnet-ajax/whats-new/release-history/q1-2010-version-2010-1-309.aspx

 

Demos:
http://demos.telerik.com/aspnet-ajax/controls/examples/default/defaultcs.aspx

 

Documentation:
http://www.telerik.com/help/aspnet-ajax/introduction.html

We are glad to announce that the Q1 2010 Release has added another weapon to RadGridView’s growing arsenal of features. This is the brand new RadDataPager control which provides the user interface for paging through a collection of data.

The good news is that RadDataPager can be used to page any collection. It does not depend on RadGridView in any way, so you will be free to use it with the rest of your ItemsControl’s if you chose to do so.

Before you read on, you might want to download the samples solution that I have attached. It contains a sample project for every scenario that I will discuss later on. Looking at the code while reading will make things much easier for you. There is something for everyone among the 10 Visual Studio projects that are included in the solution. So go and grab it.

I. Paging essentials

The single most important piece of software concerning paging in Silverlight is the System.ComponentModel.IPagedCollectionView interface. Those of you who are on the WPF front need not worry though. As you might already know, Telerik’s Silverlight and WPF controls is share the same code-base. Since WPF does not contain a similar interface, Telerik has provided its own Telerik.Windows.Data.IPagedCollectionView.

The IPagedCollectionView interface contains several important members which are used by RadGridView to perform the actual paging. Silverlight provides a default implementation of this interface which, naturally, is called PagedCollectionView. You should definitely take a look at its source code in case you are interested in what is going on under the hood. But this is not a prerequisite for our discussion.

The WPF default implementation of the interface is Telerik’s QueryableCollectionView which, among many other interfaces, implements IPagedCollectionView.

II. No Paging

In order to gradually build up my case, I will start with a very simple example that lacks paging whatsoever. It might sound stupid, but this will help us build on top of this paging-devoid example. Let us imagine that we have the simplest possible scenario. That is a simple IEnumerable and an ItemsControl that shows its contents. This will look like this:

No Paging

1. IEnumerable itemsSource = Enumerable.Range(0, 1000);
2. this.itemsControl.ItemsSource = itemsSource;

XAML

1. <Border Grid.Row="0" BorderBrush="Black" BorderThickness="1" Margin="5">
2.     <ListBox Name="itemsControl"/>
3. </Border>
4. <Border Grid.Row="1" BorderBrush="Black" BorderThickness="1" Margin="5">
5.     <TextBlock Text="No Paging"/>
6. </Border>

Nothing special for now. Just some data displayed in a ListBox.

The two sample projects in the solution that I have attached are:

• NoPaging_WPF
• NoPaging_SL3

With every next sample those two project will evolve in some way or another.

III. Paging simple collections

The single most important property of RadDataPager is its Source property. This is where you pass in your collection of data for paging.

More often than not your collection will not be an IPagedCollectionView. It will either be a simple List<T>, or an ObservableCollection<T>, or anything that is simply IEnumerable. Unless you had paging in mind when you designed your project, it is almost certain that your data source will not be pageable out of the box. So what are the options?

III. 1. Wrapping the simple collection in an IPagedCollectionView

If you look at the constructors of PagedCollectionView and QueryableCollectionView you will notice that you can pass in a simple IEnumerable as a parameter. Those two classes will wrap it and provide paging capabilities over your original data. In fact, this is what RadGridView does internally. It wraps your original collection in an QueryableCollectionView in order to easily perform many useful tasks such as filtering, sorting, and others, but in our case the most important one is paging. So let us start our series of examples with the most simplistic one. Imagine that you have a simple IEnumerable which is the source for an ItemsControl. Here is how to wrap it in order to enable paging:

Silverlight

1. IEnumerable itemsSource = Enumerable.Range(0, 1000);
2. var pagedSource = new PagedCollectionView(itemsSource);
3. this.radDataPager.Source = pagedSource;
4. this.itemsControl.ItemsSource = pagedSource;

WPF

1. IEnumerable itemsSource = Enumerable.Range(0, 1000);
2. var pagedSource = new QueryableCollectionView(itemsSource);
3. this.radDataPager.Source = pagedSource;
4. this.itemsControl.ItemsSource = pagedSource;

XAML

1. <Border Grid.Row="0"
2.         BorderBrush="Black"
3.         BorderThickness="1"
4.         Margin="5">
5.     <ListBox Name="itemsControl"/>
6. </Border>
7. <Border Grid.Row="1"
8.         BorderBrush="Black"
9.         BorderThickness="1"
10.         Margin="5">
11.     <telerikGrid:RadDataPager Name="radDataPager"
12.                               PageSize="10"
13.                              IsTotalItemCountFixed="True"
14.                              DisplayMode="All"/>

This will do the trick. It is quite simple, isn’t it?

The two sample projects in the solution that I have attached are:

• PagingSimpleCollectionWithWrapping_WPF
• PagingSimpleCollectionWithWrapping_SL3

III. 2. Binding to RadDataPager.PagedSource

In case you do not like this approach there is a better one. When you assign an IEnumerable as the Source of a RadDataPager it will automatically wrap it in a QueryableCollectionView and expose it through its PagedSource property. From then on, you can attach any number of ItemsControl’s to the PagedSource and they will be automatically paged. Here is how to do this entirely in XAML:

Using RadDataPager.PagedSource

1. <Border Grid.Row="0"
2.         BorderBrush="Black"
3.         BorderThickness="1" Margin="5">
4.     <ListBox Name="itemsControl"
5.              ItemsSource="{Binding PagedSource, ElementName=radDataPager}"/>
6. </Border>
7. <Border Grid.Row="1"
8.         BorderBrush="Black"
9.         BorderThickness="1"
10.         Margin="5">
11.     <telerikGrid:RadDataPager Name="radDataPager"
12.                               Source="{Binding ItemsSource}"
13.                              PageSize="10"
14.                              IsTotalItemCountFixed="True"
15.                              DisplayMode="All"/>

The two sample projects in the solution that I have attached are:

• PagingSimpleCollectionWithPagedSource_WPF
• PagingSimpleCollectionWithPagedSource_SL3

IV. Paging collections implementing IPagedCollectionView

Those of you who are using WCF RIA Services should feel very lucky. After a quick look with Reflector or the debugger we can see that the DomainDataSource.Data property is in fact an instance of the DomainDataSourceView class. This class implements a handful of useful interfaces:

• ICollectionView
• IEnumerable
• INotifyCollectionChanged
• IEditableCollectionView
• IPagedCollectionView
• INotifyPropertyChanged

Luckily, IPagedCollectionView is among them which lets you do the whole paging in the server. So let’s do this. We will add a DomainDataSource control to our page/window and connect the items control and the pager to it. Here is how to do this:

MainPage

1. <riaControls:DomainDataSource x:Name="invoicesDataSource"
2.                               AutoLoad="True"
3.                               QueryName="GetInvoicesQuery">
4.     <riaControls:DomainDataSource.DomainContext>
5.         <services:ChinookDomainContext/>
6.     </riaControls:DomainDataSource.DomainContext>
7. </riaControls:DomainDataSource>
8. <Border Grid.Row="0"
9.         BorderBrush="Black"
10.         BorderThickness="1"
11.         Margin="5">
12.     <ListBox Name="itemsControl"
13.              ItemsSource="{Binding Data, ElementName=invoicesDataSource}"/>
14. </Border>
15. <Border Grid.Row="1"
16.         BorderBrush="Black"
17.         BorderThickness="1"
18.         Margin="5">
19.     <telerikGrid:RadDataPager Name="radDataPager"
20.                               Source="{Binding Data, ElementName=invoicesDataSource}"
21.                              PageSize="10"
22.                              IsTotalItemCountFixed="True"
23.                              DisplayMode="All"/>

By the way, you can replace the ListBox from the above code snippet with any other ItemsControl. It can be RadGridView, it can be the MS DataGrid, you name it. Essentially, RadDataPager is sending paging commands to the the DomainDataSource.Data. It does not care who, what, or how many different controls are bound to this same Data property of the DomainDataSource control.

So if you would like to experiment with this, you can throw in any number of other ItemsControl’s next to the ListBox, bind them in the same manner, and all of them will be paged by our single RadDataPager.

Furthermore, you can throw in any number of RadDataPager’s and bind them to the same property. Then when you page with any one of them will automatically update all of the rest.

The whole picture is simply beautiful and we can do all of this thanks to WCF RIA Services.

The two sample projects (Silverlight only) in the solution that I have attached are:

• PagingIPagedCollectionView
• PagingIPagedCollectionView.Web

IV. Paging RadGridView

While you can replace the ListBox in any of the above examples with a RadGridView, RadGridView offers something extra. Similar to the DomainDataSource.Data property, the RadGridView.Items collection implements the IPagedCollectionView interface. So you are already thinking: Then why not bind the Source property of RadDataPager to RadGridView.Items? Well that’s exactly what you can do and you will start paging RadGridView out-of-the-box. It is as simple as that, no code-behind is involved:

MainPage

1. <Border Grid.Row="0"
2.         BorderBrush="Black"
3.         BorderThickness="1" Margin="5">
4.     <telerikGrid:RadGridView Name="radGridView"
5.                              ItemsSource="{Binding ItemsSource}"/>
6. </Border>
7. <Border Grid.Row="1"
8.         BorderBrush="Black"
9.         BorderThickness="1"
10.         Margin="5">
11.     <telerikGrid:RadDataPager Name="radDataPager"
12.                               Source="{Binding Items, ElementName=radGridView}"
13.                              PageSize="10"
14.                              IsTotalItemCountFixed="True"
15.                              DisplayMode="All"/>

The two sample projects in the solution that I have attached are:

• PagingRadGridView_SL3
• PagingRadGridView_WPF

With this last example I think I have covered every possible paging combination. In case you would like to see an example of something that I have not covered, please let me know.

Also, make sure you check out those great online examples:

• WCF RIA Services with DomainDataSource
• Paging Configurator
• Endless Paging
• Paging Any Collection
• Paging RadGridView

Happy Paging!

Download Full Source Code

This is the final blog post from the pre-release series. In it we are going to share with you some of the updates coming to our reporting solution in Q1 2010.

A new Declarative Data Source Engine will be added to Telerik Reporting, that will allow full control over data management, and deliver significant gains in rendering performance and memory consumption. Some of the engine’s new features will be:

• Data source parameters - those parameters will be used to limit data retrieved from the data source to just the data needed for the report. Data source parameters are processed on the data source side, however only queried data is fetched to the reporting engine, rather than the full data source. This leads to lower memory consumption, because data operations are performed on queried data only, rather than on all data. As a result, only the queried data needs to be stored in the memory vs. the whole dataset, which was the case with the old approach

  

• Support for stored procedures - they will assist in achieving a consistent implementation of logic across applications, and are especially practical for performing repetitive tasks. A stored procedure stores the SQL statements and logic, which can then be executed in different reports and/or applications. Stored Procedures will not only save development time, but they will also improve performance, because each stored procedure is compiled on the data base server once, and then is reutilized. In Telerik Reporting, the stored procedure will also be parameterized, where elements of the SQL statement will be bound to parameters. These parameterized SQL queries will be handled through the data source parameters, and are evaluated at run time. Using parameterized SQL queries will improve the performance and decrease the memory footprint of your application, because they will be applied directly on the database server and only the necessary data will be downloaded on the middle tier or client machine;

  

• Calculated fields through expressions - with the help of the new reporting engine you will be able to use field values in formulas to come up with a calculated field. A calculated field is a user defined field that is computed "on the fly" and does not exist in the data source, but can perform calculations using the data of the data source object it belongs to. Calculated fields are very handy for adding frequently used formulas to your reports;
• Improved performance and optimized in-memory OLAP engine - the new data source will come with several improvements in how aggregates are calculated, and memory is managed. As a result, you may experience between 30% (for simpler reports) and 400% (for calculation-intensive reports) in rendering performance, and about 50% decrease in memory consumption.
• Full design time support through wizards - Declarative data sources are a great advance and will save developers countless hours of coding. In Q1 2010, and true to Telerik Reporting’s essence, using the new data source engine and its features requires little to no coding, because we have extended most of the wizards to support the new functionality. The newly extended wizards are available in VS2005/VS2008/VS2010 design-time.

More features will be revealed on the product's what's new page when the new version is officially released in a few days. Also make sure you attend the free webinar on Thursday, March 11th that will be dedicated to the updates in Telerik Reporting Q1 2010.

While we are still on the performance subject, I want to spend some time to introduce the power of UI Virtualization in the RadCoverFlow for Silverlight control coming with the 2010 Q1 release.

The two most common scenarios for using a CoverFlow is to either create a navigation menu that features a small number of items or  build a browsing control for images or videos that can feature up to a million of items. The first case is quite straight-forward. For a navigation control you generally have not more than 10-12 items which are handled with ease in terms of performance and browsing experience. However, when you have say 1000 or more items the things get a little bit more interesting in terms of memory usage and CPU resources, because for every item a specific CoverFlowItem (also called container) has to be created and stored in the memory and has to have various transformations applied to it during animation. Since drawing each item container and keeping it in the memory is expensive in terms of memory and CPU resources the concept of UI Virtualization can be very powerful to optimize the experience of browsing with a CoverFlow control. UI Virtualization simply creates and uses approximately the number of item containers that are visible on the screen.

To enable UI Virtualization you just have to set the IsVirtualizing property to True. This will instruct the control’s panel to dynamically create and recycle item containers from its ItemContainerGenerator and assign the appropriate items to the already generated containers. Therefore, you cannot explicitly add CoverFlowItems to the control neither you can declare them in xaml or using the Items property in the code. You must always use the ItemsSource property to specify a collection of items whenever the IsVirtualizing property is set to true as with every other UI virtualizing control. Note that the CoverFlow control does not feature any built-in scrolling functionality with or without UI Virtualization, thus if you want a scrolling behavior you can read my blog post on how to create a simple, but powerful Navigation for CoverFlow.

UI Virtualization for CoverFlow is just a tiny part of the enormous efforts we put to optimize the client experience of our controls. I am really glad that the UI Virtualization is already a part of our feature-set, and works both in Horizontal and Vertical orientations.

To read more about performance gains and other cool stuff that will be part of our 2010 Q1 milestone release check our marketing blog post. For in depth information on UI Virtualization in Silverlight and WPF you can read about the VirtualizingStackPanel here.

Q1 2010 will be a milestone release for our enterprise-grade ORM. With it we will introduce the new Visual Designer for OpenAccess ORM. The designer will give developers the ability to map their databases on a specially designed graphical surface as well as perform modifications to the mapping process and the domain model. Some of the features included in the designer are:

• The DSL Designer – This is a specialized visual editor that visualizes the mapped classes and their relationships. You will be able to easily interact with them with simple point-and-click actions. The designer will also offer a contextual menu for the most used operations; zoom in/out functionality, export to image and more.

• Mapping Details Editor – It will let you specify the class and association mappings required for the runtime. The tool will also allow you to configure class inheritance and stored procedures for CUD operations for the classes updates.



• Schema Explorer – This panel will show the relational layer from the database in a hierarchical order. There you will be able to specify which elements should be mapped to or removed from the conceptual part of the domain model. It will also allow drag and drop mapping.



• ‘Update From Database Model’ Wizard – This dialog will show the difference between the database content and the relational layer of the actual model in terms of what is still missing, should be removed or modified in the model. From there you will be able to insert unmapped tables, views or stored procedures into your domain model. It uses unique approach that can show all the details (differences, etc) in the compared models.



• Entity Diagram Explorer – It will show the conceptual layer of the model, or to put it simply the classes that will be generated. It contains the same information that is in the designer but in a hierarchical order. Modifications of their basic properties and operations are allowed through the standard properties window.



• Model Settings Dialog – With it you will be able to fine tune the behavior of your domain model by allowing you to specify naming, code generation, caching and concurrency control settings.

A unique feature of the Visual Designer for OpenAccess ORM will be the Validation Rules. It will help validate your model once your finished working with it and eliminate mistakes like missing primary keys. We have also conveniently created toolbox items that will allow you to perform the basic drag and drop mapping, set table relationships and inheritance as well as insert comment.

With Q1 2010 OpenAccess ORM will introduce support for the embedded SQL database engine VistaDB. Finally the already popular Data Services Wizard, that automates the process of connecting OpenAccess ORM to web services like Astoria and WCF, will no longer come as a separate installation but will be fully integrated in Telerik OpenAccess ORM Q1 2010.

Stay tuned to this blog for more details on the upcoming Q1 2010 release.

Now we're starting to dive into the world of Prism and modular development as well as a very standard, event driven, code-behind way of handling this project- meaning now we finally get to see some code!  To start things off, we'll look at the slightly more in-depth approach of beginning an application using Prism/MVVM and what it entails.  Also, to make one distinction early on, since I'm using the same database and WCF RIA Services to handle my data transfer, I've created the code-behind project within the same solution, so when I am in the Recruit project or any module, I'm working on the Prism/MVVM version, but when you see me in RecruitCB (clever shortening of Recruit Code-Behind), I'm using the code-behind version.

Setting up the Prism Project

The first thing I need to do is start a new Silverlight Application.  Once this is all setup, I have to do two things to start Prism-ifying the project- the Bootstrapper and Shell.  Bootstrapper is a class which will be used to initialize modules, load the shell, and take care of any initialization logic, whereas Shell is just the MainPage.xaml renamed.

Since we're using Prism, we also need references to the following assemblies:

Since our shell is going to be all XAML, we'll look at the BootStrapper first.  When using Prism/Unity (the container for Prism, but you could also use CastleWindsor, Ninject, etc.), our BootStrapper implements UnityBootstrapper, the two most important methods from which, for our purposes, are CreateShell() and GetModuleCatalog().  CreateShell is going to create an instance of our shell using the Unity container and set that as the current RootVisual of our application.  GetModuleCatalog, on the other hand, is one of the ways we can gather and initialize our modules. With all those in place, the code for this basic bootstrapper setup looks like this:

public class Bootstrapper : UnityBootstrapper {     protected override DependencyObject CreateShell()     {         Shell shell = Container.Resolve<Shell>();         Application.Current.RootVisual = shell;         return shell;     }     protected override IModuleCatalog GetModuleCatalog()     {         ModuleCatalog catalog = new ModuleCatalog();         // add modules here         return catalog;     } }

These, or at least the GetModuleCatalog, will get a little more robust as we move forward, but this handles our BootStrapper.cs for right now.  So what's next?  We'll step into the Shell.XAML.

Shell.XAML can be thought of as your main display that will hold regions (this term means something for Prism) to load modules into.  I know that I want a basic setup which has a title at the top, a status notification area in the upper right (to say 'Loading', etc.), a menu on the left, and the bulk of the window to be the main content region.  The resulting XAML looks something like this:

<Grid x:Name="LayoutRoot">     <Grid.ColumnDefinitions>         <ColumnDefinition Width="200" />         <ColumnDefinition />     </Grid.ColumnDefinitions>     <Grid.RowDefinitions>         <RowDefinition Height="48" />         <RowDefinition />     </Grid.RowDefinitions>     <Border Grid.ColumnSpan="2">         <Border.Background>             <LinearGradientBrush StartPoint=".5,0"                                  EndPoint=".5,1">                 <GradientStopCollection>                     <GradientStop Color="LightGray"                                   Offset="0" />                     <GradientStop Color="LightBlue"                                   Offset=".9" />                     <GradientStop Color="White"                                   Offset="1" />                 </GradientStopCollection>             </LinearGradientBrush>         </Border.Background>         <StackPanel Orientation="Horizontal"                     HorizontalAlignment="Left"                     VerticalAlignment="Center"                     Margin="24,0,0,0">             <TextBlock Text="Telerik"                        FontWeight="Bold"                        FontSize="24" />             <TextBlock Text="Recruiter"                        FontSize="24" />         </StackPanel>     </Border>     <!-- Notifications Region -->     <ContentControl x:Name="NotificationRegion"                     HorizontalAlignment="Right"                     Grid.Column="1"                     regions:RegionManager.RegionName="NotificationRegion" />     <!-- Menu Region -->     <ContentControl x:Name="MenuRegion"                     Grid.Row="1"                     regions:RegionManager.RegionName="MenuRegion" />     <!-- Main Content Region -->     <ContentControl x:Name="MainRegion"                     Grid.Row="1"                     Grid.Column="1"                     regions:RegionManager.RegionName="MainRegion" /> </Grid>

I mentioned the whole 'region' thing before, so you must be wondering what 'regions:RegionManager.RegionName=""' is all about.  This works with a RegionManager in Prism to determine where on your page a view will display.  Also for reference, the regions namespace is coming from 'clr-namespace:Microsoft.Practices.Composite.Presentation.Regions'.  Once we dive into modules a bit in the next post you'll see where these regions come into play.

The last step to get a fully functional husk of a Prism application going is to do a little modification to the App.xaml.cs, which holds our startup and shut down logic for the application.  Normally you'd see some of that rootvisual logic that we put into the BootStrapper in the App.xaml.cs, so we've got to replace that with...

private void Application_Startup(object sender, StartupEventArgs e) {                Bootstrapper bootstrapper = new Bootstrapper();     bootstrapper.Run(); }

One other tiny note, since I wanted to use our awesome Windows 7 theme across the application, I also included this line in the public App() area just above startup, right above the InitializeComponent() call:

StyleManager.ApplicationTheme = new Windows7Theme();

 

Setting up the Code-Behind Project

Things are infinitely quicker to setup for the code-behind project, which is going to look like this from the get-go:

Since we aren't using Prism we don't have to worry about a Shell, a BootStrapper, or starting our BootStrapper in the App.xaml.cs (although we are still adding the StyleManager line for our Application-wide Windows 7 theme), which means all we're worrying about is the MainPage.Xaml- and we don't even have to change the name to Shell!  One of the nicest things too is that I already designed my Shell.Xaml, so I can copy and paste the entire code snippit above into MainPage.Xaml and have a working UI in seconds.  The only real change I need to make is to strip out 'region' references, so the changed part of the xaml code now looks like:

<!-- Notifications Region --> <ContentControl x:Name="NotificationRegion"                 HorizontalAlignment="Right"                 Grid.Column="1" /> <!-- Menu Region --> <ContentControl x:Name="MenuRegion"                 Grid.Row="1" /> <!-- Main Content Region --> <ContentControl x:Name="MainRegion"                 Grid.Row="1"                 Grid.Column="1" />

Right now the line of thought is that since I can set the .Content of a ContentControl, I can either load separate Xaml UserControls into those placeholders (possible option) or instead build out the menu and notification area in the XAML and just use the MainRegion ContentControl for loading different controls or views that I will need.  That would let me load things as I please and easily handle switching between sections of the application without much effort.

Part 3 - The End Result

While I am going to have to put a bit more plumbing into the Prism version to get it read for things like commands, events, and swapping views, we basically have the core UI setup and both projects in the form that we can run them and get a nice UI running in my browser:

Pretty neat, don't you think?  Next time, we're going to look at actually getting some functionality in here.  For the Recruit (Prism project), that means setting up an Infrastructure project and laying the groundwork for my modules as well as the WCF RIA Services link, whereas for RecruitCB (code-behind project) I'll have to setup WCF RIA Services and make a few control shells for where I'll be implementing functionality down the road.

Everyone likes to look good. We put on our new clothes when we schedule our meetings, show some data or go to the movies. And this spring we all will go freshen up our wardrobes.

 

…

 

For the past year we have been working out showing muscle. Our focus was on performance, feature richness and building a complete tool set. Currently there are 40+ controls in the suite ready, willing and able to work together to bring your Rich Business Applications to the next level. Being where we are it was time to add a touch of brilliance and make them look great together too.

 

 

As a part of out 2010.Q1 offering we want to bring an unparalleled visual richness to your applications. To achieve that we have done a major rework of all our themes. We used a uniform templating approach across all controls, streamlined naming conventions for resources and delivered a much more consistent look of the controls along the way.

 

 

No theme was left untouched. Some needed more attention than others, some were rebuilt from the ground up, and some were just tweaked for consistency. In any case the result is there – a sleek and consistent new look across the entire suite.

 

 

As in life beauty comes at a price. Achieving these results required, in some cases, extensive XAML rework which will be a breaking change for many of you who have heavy customizations or have built custom themes. But be not afraid as we will be there with you every step of your migration process, no matter how rocky it might be.

 

…

 

Yes. Everyone likes to look good. But this time putting on some make up gets us stellar.

With the Q1 2010 Release of the RadControls for WinForms, we are bringing you a powerful new version of Visual Style Builder (VSB). This new version of VSB makes building themes a breeze with its new Theme Repositories feature. Today I thought I would spend some time going over the basics of VSB and its new system of Theme Repositories.

Theme Repositories

In previous versions of VSB, it was only possible to change theme properties on a per-element basis. This means that when building a theme, you actually had to select each individual element of every single control and modify its properties separately. With the new version of VSB, we've overcome the shortcomings of this approach by creating the Theme Repository. A Theme Repository is a reusable container for property settings that can be applied to elements and primitives based on the Telerik Presentation Framework (TPF). Currently, there are five types of repositories.

Fill Repository

Applies To: Elements that support FillPrimitive
Purpose: Defines how an element should be filled.

Figure 1. Creating a Fill Repository

Border Repository

Applies To: Elements that support BorderPrimitive
Purpose: Defines what an elements borders should look like.

Figure 2. Creating a Border Repository

Arrow Repository

Applies To: Elements that support ArrowPrimitive.
Purpose: Defines what an elements arrows should look like.

Figure 3. Creating an Arrow Repository

Text Repository

Applies To: Elements that support TextPrimitive.
Purpose: Defines the font/text properties that should be used in an element.

Figure 4. Creating a Text Repository

Image Repository

Applies To: Elements that support ImagePrimitive.
Purpose: Defines the properties for an image that should be used in an element.

Figure 5. Creating an Image Repository

Working with Theme Repositories

One of the primary benefits of Theme Repositories is that they are extremely easy to work with. To create a theme repository, you simply need to select the particular element of a control that you would like to create the repository for. Once doing so, clicking the "Create Repository" button will display a dialog that allows you to create a repository specific to the type of primitive(s) the selected element can use.

After you've created a repository, you can apply it to your object by drag-and-dropping it over the element state you would like it to be applied for. You can reuse your theme repositories as many times as you'd like wherever they are supported in the RadControls for WinForms.

Figure 6. Working with Theme Repositories

So, as you can see, building themes becomes a breeze when working with Theme Repositories...

Hey everyone!  This past week/weekend I was in Canada to speak at two user groups and a code camp (could be a sitcom title) on some Silverlight related topics.  It was very exciting to be heading to the country where the Winter Olympics were happening.  Above and beyond that, according to my community manager (a Canadian) I was going to get to experience the rich culture that Canada has to offer and get a lifetime of experiences in my short time there. 

So what did I show up to?

Canada is cold!!!  Late February in Saskatchewan is not the balmy beach weather you would expect, but rather the frozen tundra and more ice than I've seen this entire winter in the Boston metro area.

All joking aside though, I had a great time in my three city tour and I wanted to thank a few people for their hard work in pulling these events off:

• Jennifer Pearcey from the Saskatoon .Net User Group set up a great meeting around their local college, however (and I don't blame you Canadians for this or anything) thanks to the US beating Canada in hockey, there was an epic Canada vs. Russia match at the same time as my talk.  For those of you who chose national pride over .Net goodness, slides and code samples are below. :)
• Gary Pronych from the Regina .Net User Group also set up a meeting at the local college (I sense a theme here), at which I had a lot of fun and got to tackle some good questions concerning the current state of Silverlight, WCF RIA Services, MEF, and other surrounding technologies.
• D'Arcy Lussier from the Winnipeg Code Camp and his crew arranged an awesome code camp- for most tracks (besides the one I was speaking at) it was a really tough choice on where to go!  It was also nice getting to connect with some local (and not so local) speakers there as well, all part of the very active community they have north of the border.

I had a lot of fun with the "Do's and Don'ts of Rich Client Development" and "Silverlight, Prism, and MVVM - The RIA Trifecta" talks that I presented and look forward to the next time I get to be up in the area.

You can find the slides and source code for both talks right here.

Join our webinar to get started with Telerik WebUI Test Studio and see how you can create automated tests in less than 15 minutes. The event will be about half an hour and will take place on Thursday, March 4th @ 11AM EST.
We'll also be happy to answer all your questions after the demo. Register here>>

The Telerik Extensions for ASP.NET MVC continue to march triumphantly towards their v1 in the Q1 2010 release. Thanks to your valuable feedback during the past few months, we were able to shape our roadmap and produce the next batch of UI extensions: TreeView, Calendar, DatePicker and a set of 4 Input components - NumericTextBox, CurrencyTextBox, PercentTextBox and IntegerTextBox. All of them are lightweight, semantically rendered, embracing the ASP.NET MVC principles and designed to deliver maximum performance to your MVC applications.

The flagship component, Grid for ASP.NET MVC, matures more and more with its latest enhancements. You can now achieve multi-level grouping, or edit and delete data through the integrated editors: Input, DatePicker and Calendar. The later are also introduced in the suite as standalone UI extensions. The Input components - NumericTextBox, CurrencyTextBox, PercentTextBox and IntegerTextBox  - validate the input of numeric, integer, currency or percentage entries. They automatically handle the parsing of values that the users enter and format their values for display. And last, but not least the TreeView component debuts in the suite with load on demand, semantic rendering and node drag and drop.

 

All UI extensions draw on the power of the jQuery library for advanced visual effects. You can enjoy smooth jQuery animations and further customize them with any settings relevant for your scenario.

Finally, styling your ASP.NET MVC applications is now no brainer with the Extensions’ support for our unique Visual Style Builder. The tool allows skinning and customization of the MVC components through a visual interface without the need to know the front-end structure of the components. 

Licensing:
With the Q1 2010 release, the Telerik Extensions will ship under a dual licensing model:

• GPLv2 - a very popular and common open source license.
• Commercial license - Developer License with Subscription and Priority Support at $999 – this license is suitable for those that need dedicated support or need to use the Extensions in an environment where open source software is hard to get approved.

 

Stay tuned for more pre-release bits this week!

The RadSlider is getting a subtile, but still important update for its visual appearance in the Q1 2010 release of RadControls for ASP.NET AJAX. We made the look and feel of all skins be consistent so you can have more choices when it comes to picking the right one for your application.

Here is the comparison between the old an new look:

The first difference is that we have added a border at both ends of the slider track. The border is not part of the track itself. The second difference is that all slider arrows now have a background and look like buttons.Finally, the drag handle orientation on some skins has been changed. The slider will now actually point the drag handle depending on where you put the track (TrackPosition property).

We hope that these changes will improve the usability of the control and make it easier to integrate with other controls in your application. If you wish to upgrade to Q1 2010, but keep the old look, then you can simply set the slider properties EnableEmbeddedSkins and EnableEmbeddedBaseStyleSheet to false and load the Q3 2009 skin and base stylesheet manually on the page. Click here for a sample page that shows how to do this (using the old Default skin).

 

Let’s face it: we did not get the response rate we expected for the Reporting case-study contest. Naturally, we were starting to wonder why, since Telerik Reporting is used by thousands of developers world-wide, and we have contacted them all regarding this contest. So the reason must be somewhere else. And just when we started scratching our heads, the reason presented itself before us. As with all things unexplainable, it was quite simple.

It turned out that time was not enough. As the deadline for submission got closer we started receiving numerous requests from clients for extending the deadline so that they have more time to prepare for the contest. To keep the competitive spirits alive, we decided to respect their requests and set a new deadline for case study submissions. This should give you some extra time for finishing up those WIP projects. And, in case you have missed the initial announcement about the Reporting case-study contest, this is your second chance to win one of the COOL PRIZES!

The new dates are:

• March 31, 2010 – deadline for new entries
• April 2, 2010 – community voting starts
• April 7, 2010 – voting ends
• April 8, 2010 – WINNER IS ANNOUNCED!!!

Good luck to all!

We apologize for any inconvenience this may cause to current participants.

The Q1 2010 Beta release of RadControls for ASP.NET AJAX uncovered the veil about what is cooking for you for the official Q1 2010 release of the suite, namely:

- Native NET 4 builds of Telerik.Web.UI.dll and Telerik.Web.Design.dll (currently built against VS 2010/.NET 4 RC, later compiled against the RTM when it comes out)
- Javascript Intellisense support for RadControls for ASP.NET AJAX client scripts under VS 2008/VS 2010

 

Closely following the Microsoft's .NET framework release schedule and being one of the first who announced VS 2010 Beta2 and RC support, we are going to ship .NET 4 assemblies of our controls residing in /bin40 folder of the RadControls for ASP.NET AJAX installation. An important detail is that now the assemblies will be separated into /bin20, /bin35 and /bin40 folders (as opposed to the current /bin and /bin35 folders). The dlls are grouped in conjunction with one single criterion - the .NET framework they are built against. Thus depending on the targeted .NET framework, you will be able to choose the relevant assemblies and plug them in your project.

The screenshot below visualizes the new folder structure:

What about the JavaScript IntelliSense? Well, I believe this will be the shiny gem that each of us who use RadControls for ASP.NET AJAX and write javascript code will cherish. No need to burry yourself in the client API documentation, no more annoying js errors being generated from non-existing properties/methods or mistyped code slices! Simply register Telerik.Web.UI.Common.Core.js using RadScriptManager/MS ScriptManager under VS 2010 or MS ScriptManager under VS 2008 and enjoy the out-of-the-box JavaScript IntelliSense in the markup of your pages.

VS 2008

An important detail here is that the Telerik static client library exposes to<RadControlName>(object) and find<RadControlName>(id, parent) methods which gives you the ability to cast or find Telerik AJAX control's client object and then the IntelliSense will expose directly its properties, methods and events. Additionally, you will get information about the client methods signature and the type of the arguments passed to or returned from them.

 

Finally, I will give you another sneak peak on a new feature that is shaping for the Q1 2010 release - VS 2010 Extension Manager deployment for Telerik Visual Studio Extensions for ASP.NET AJAX:

 

 

Already asking yourself when you will be able to get your hands on the Q1 2010 release? It is just around the corner and will go live by the end of the next week. The countdown already started...

During the past year, we received many suggestions for new features and bug fixes for RadGridView for WinForms. After analyzing them we realized that we should do a major refactoring of both the data layer and the UI of our grid control. Then we set an ambitious goal -- to refactor the control and implement the most wanted features. This is obviously a massive task and the new grid control will not be part of Q1, but it is coming up afterwards as beta, and will be officially available for Q2 2010. This will give us enough time to test all the new features and to make a really stable product.

Since we are working on vNEXT, there will be no new feature added to the current Q1 2010 release of the grid. Still, we are working on both versions in parallel to address the issues reported by our customers during the previous quarter.

I want to tell you about the new features that will be available in Q2 2010:

First of all, we refactored the data layer to be independent from RadGridView. It will be used in other data bound controls, and will bring additional functionality to some of the other controls such as RadComboBox. The new data layer will consume substantially less memory and will be faster in various scenarios than the ongoing one. It will be fully customizable in terms of grouping, sorting, and filtering. The most significant change is in the hierarchy support. The current version supports only relational hierarchy, whereas the new one will support self-referencing hierarchy, object-relational mapping, and load on demand. To make the list complete, our new data layer will be compatible with LINQ and Telerik OpenAccess ORM.

There is a dramatic change in the UI too. The connection between data layer and UI has been fully re-engineered. Now the new UI uses general virtualization panel to virtualize rows and cells. In this way we can support spreadsheet scenarios, and a large number of columns will not slow down the grid. The same virtualization will be used in other controls as well. The new grid supports multiple views that can be re-arranged in a dock panel. It will be also easy to define your own view.

Despite all changed, we tried to keep the breaking changes to a minimum.

Let me concentrate on some of the upcoming features in more detail:

1. Virtualized columns. With the new scrolling and virtualization in RadGridView, the number of columns is irrelevant. In combination with the virtual mode, you can use the grid as a spreadsheet:
   
   
    
2. Split grid, both horizontally or vertically. Notice the details panel at the bottom -- this is a custom view which is updated automatically:
   
   
    
3. Row/Column pin position, which will allow you to pin every row at top/bottom, and every column to left/right.
   
   
    
4. Self-referencing hierarchy. One much requested feature was to present tree-like data in RadGridView. This would be possible with the self-referencing hierarchy.
    
   

We hope you will find the new features handy, and will have some available time to test the beta once it is out. If you have any ideas about the development of RadGridView, or you have faced issues using the control, please feel free to share them with us.

We had a great Agile seminar yesterday in Pune, India. You can download the seminar slides here.

A special thanks to Telerik, the Mahratta Chamber of Commerce, Industries and Agriculture and the team from e-Zest for planning such a successful event. Usually as the speaker I get all the glory, so here is the photo of me with the folks who made it happen, they deserve the glory:

Technorati Tags: Agile,Pune

As Q1 2010 is approaching, we thought it would be a good idea to tell you a few words about the new features in RadScheduler for WinForms.

RadScheduler for WinForms will include a brand new Timeline View, designed to display continuous schedule for one or multiple resources. Time-slot duration, time-slot cells count, visible resources count and view's duration will be fully customizable. For example you can set the time-slot duration to any value from 15 minutes to 1 year and restrict your scheduler view from 01/01/2009 to 01/01/2011.

The screenshot below shows a timeline view grouped by resources. You can dynamically move an appointment from one resource to another using drag and drop.

You can also see the new features in the RadControls for WinForms Q1 2010 Beta release.

Download the Beta now, give it a try and send us any feedback you have!

Telerik has released the latest beta of the OpenAccess Data Service Wizard. We now support Visual Studio 2010 RC! You can also choose to use WCF 4.0 as one of the services you can build. Based on your feedback we also added a new feature: the ability to automatically generate dependent entities.

Download it today and give us your feedback. Next stop is the full release as part of our 2010 Q1 release of OpenAccess. See the OpenAccess roadmap here.

 

Technorati Tags: Telerik

For anyone who tuned into part 1 of this series, there was an interesting comment from Ben (one of the Telerik MVPs who also shows up quite often with intelligent commentary in a variety of locations) about the idea of using Prism, MVVM, and WCF RIA together in their current state.  This actually fell in line with a number of other conversations I have had with developers over the last few weeks and I realized something very important- he's quite right about the state of things. 

Much like 7 is the magic number for Windows, 4 is going to be the magic number for Silverlight.  With .Net 4/Silverlight 4 we get a number of new goodies to play with, with MEF being at the top of my list for things to explore.  Plus, at that point (or soon thereafter) we should hopefully see a full version of WCF RIA Services that addresses some of the quirks in the current implementation.  If all these stars align we will soon after that see Prism 4 (David Hill covers the Prism 4/MEF story excellently in this post), which will give a very compelling story for modular development and how all these different pieces tie together into one cohesive story. 

All that being said, I'm stubborn so I am going to keep on with the application as described... but with a twist!  At the same time I am developing sections of the application with Prism 2, MVVM, and WCF RIA Beta, I'm also going to create a parallel application that demonstrates the same functionality, except with the event-based, code-behind model (and WCF RIA Beta).  This way, I can explore both the way 99% of people are developing RIA's (that stat belongs to Ben, but I trust him :D) as well as show how, with the current betas and implementations, you can create the same thing using Prism/MVVM/WCF RIA.  This will also create for an interesting look at updating the app to Silverlight 4 down the road and we can examine how much cleaner the planned frameworks will make things versus the approach that needs to be taken with how things are.

So where are we now?  Well, as stated I am looking to develop version A of the application using the MVVM pattern.  This opens up some interesting questions, since I want to keep everything as disconnected and modular as possible...

• I want this to be modular, but how will they tie together? 
• How will I handle communication within the application?  There needs to be some way to work between modules.
• How about the UI?  I need some process to handle what will be shown and where it will be shown, with the option to swap views as needed for different functionality.
• If I can't use events/code-behind, how will I handle user interaction?  Something needs to give me access to commands that I can use to react to UI events.

This laundry list of concerns can either be handled through blood, sweat, and toil, or I can take advantage of one of the many frameworks that exist already to assist with these fundamental questions.  My framework of choice is the Composite Application Guidance from the Microsoft Patterns and Practices team, although most of you will know this as Prism:

For what we need here, Prism fits the bill in the following ways:

• IRegionManager - handles inserting views into pre-defined regions as well as switching out views
• IEventAggregator - handles the publishing and subscribing of events within the application for de-coupled communication
• CompositePresentationEvent - works with the event aggregator, these allow me to send info back and forth between modules
• IUnityContainer - our bucket of goodies that holds references to go between the application

As this series unfolds, we're going to see how these different elements all play an important role in solving the MVVM challenges I listed above.  Beyond that, we're going to see how they compare to the event/code-behind approach and what it takes to get the same functionality in our applications.  Of course, both of these are going to be done using the Telerik RadControls for Silverlight, so you can see that whichever way you are leaning in your development, Telerik has you covered with our high performance and feature rich controls.

Next stop, putting things together and creating our shell/module infrastructure as well as the setup for the code-behind application.