Telerik Blogs | Desktop | WinUI

What’s New in R2 2023 with Telerik Desktop and Mobile Components

2023-06-07T13:49:37Z

Get ready for the latest update on our Progress Telerik products for mobile and desktop as we unveil the highly anticipated R2 2023 release.

We are thrilled to share the exciting features and improvements that await you in R2 2023 from our Progress Telerik mobile and desktop UI component libraries. So, sit back, relax and keep reading to stay in the loop!

Telerik UI for .NET MAUI

Prepare for an exhilarating update in R2 2023 as Telerik UI for .NET MAUI unveils a series of exciting enhancements. I am thrilled to introduce six brand-new controls: Calendar, PDF Viewer, Chat, SlideView, RichTextEditor and TreeView, each designed to empower your app development journey. In addition, we have taken steps to refine and enrich our powerful DataGrid control, unlocking even more possibilities. Let’s have a sneak peek at the most interesting stuff we have for you in this release.

Calendar

The new addition to the UI for .NET MAUI family is the Calendar component. It allows you to select single or multiple dates by navigating easily between decades, years and months. The control is culture-aware by providing globalization support. It also provides support for scrolling and navigation, blackout dates and much more.

Here is a list of the main features of the control:

Different display modes: Calendar features year, month, decade and century display modes.
Date Ranges: Restrict the visible/selectable dates in the Calendar by utilizing MinDate and MaxDate properties.
Different selection modes: The component provides different types of selection—Single, Multiple, Range or disabling the selection.
Buttons for navigation in the current view: You can easily navigate in the current view by using the buttons in the calendar header.
Hide the names of the display days in month view.
Format the header text for the corresponding view.
Templates support: For customizing the days, months, years and decades in the corresponding views.
Commands support: For navigating in the current view or between the views.
Styling API: You can style the Calendar border, header border and text, navigation buttons and the content of the corresponding view.

For more information on getting started with the Telerik UI for .NET MAUI Calendar control, visit the documentation.

PDF Viewer Component

One of the highly requested components for our UI for .NET MAUI suite was the PDF viewer. I am happy to share that it is now available with our latest release. This component empowers the users of your application to directly open and view PDF documents within their mobile or desktop app, eliminating the need for any external software installation or switching between different applications. You can visualize PDF documents that include images, shapes, different colors, ordered and bulleted lists and more.

Here are some of the key features to look for:

Various document source options: You can load the PDF document from a stream, from a file added as an embedded resource or a file located on the device, etc.
Zooming functionality: The component provides an option for zooming in and zooming out the content of the document.
Commands support: The PDF Viewer component offers support for a variety of commands, such as ZoomIn, ZoomOut, NavigateTo (NextPage, PreviousPage, Page) and FitToWidth.
Single page and Continuous Scrolling support: You can choose between two layout modes that allow the document to be scrolled in the viewer.
Flexible styling API: You can easily style the toolbar per your requirements.

For more information on getting started with the PDF Viewer control, visit the documentation.

Chat Component (Conversational UI)

The Chat control in Telerik UI for .NET MAUI empowers you to build contemporary chat experiences in your .NET MAUI apps. It smoothly integrates with popular chatbot frameworks and effortlessly facilitates peer-to-peer conversations.

The component offers a diverse range of customizable message formats like cards, pickers and suggestions. It also enables you to effortlessly replace forms with an instinctive conversational UI. You can modify messages and cards to include text, images and other elements or incorporate details such as message timestamps, sender/recipient names, avatars and much more.

For more information on getting started with the Telerik UI for .NET MAUI Chat control, visit the documentation.

SlideView Component

The new SlideView component provides a visually appealing and interactive way to present information or showcase visual content. Whether your goal is to create an image gallery or improve navigation within your .NET MAUI application, the SlideView component offers a comprehensive set of features and customizable options to fulfill your requirements.

Here are some of the key features to look for:

Item Template: Allows you to present the data in the views in the most suitable way for your scenario.
Control Template support: You can change the appearance of the SlideView component through a Control Template.
Customizable indicators and slide buttons: The SlideView allows you to customize the appearance of the indicators and slide buttons.
Commands support
UI virtualization

For more information on getting started with the Telerik UI for .NET MAUI SlideView control, visit the documentation.

Rich Text Editor Component

The Telerik UI for .NET MAUI RichTextEditor control empowers users to generate rich textual content using a comprehensive array of tools. These tools simplify the creation, editing and formatting of text, paragraphs, lists, hyperlinks and various other elements.

The Telerik UI for .NET MAUI RichTextEditor control comes with a multitude of editing capabilities, including:

Text formatting, such as bold, italic, underline and strikethrough
Font manipulations, such as size, family and color
Text selection
Hyperlink manipulations such as creating, editing and removing hyperlinks
Read-only state that does not allow text editing
Copy/Paste/Undo/Redo editing actions

It also has an integrated ToolBar, which effortlessly connects to the commonly used commands provided by the control.

For more information on getting started, visit the Telerik UI for .NET MAUI RichTextEditor control documentation.

TreeView

The new TreeView component in UI for .NET MAUI allows you to visually represent hierarchical data in a collapsible and expandable tree structure. It provides users with an intuitive way to navigate and explore complex information, such as folder structures, organizational charts or category hierarchies.

Here are some of the key features to look for:

Hierarchical navigation
Expand/Collapse items
Commands support
CheckBox support
UI virtualization
Single and multiple selection modes
Empty template support
Flexible styling API

For more information on getting started, visit the Telerik UI for .NET MAUI TreeView control documentation.

DataGrid Empty Template Support

The Telerik UI for .NET MAUI DataGrid control introduces the Empty Template functionality. This feature enables you to inform your end users when the control has no data to display.

DataGrid DataTable support

You can bind your .NET MAUI DataGrid to a DataTable and have access to all the cool features. You can add, remove, select, edit item(s) and update DataGrid’s ItemsSource. You can also perform commands and operations like filtering, sorting, grouping and selection.

.NET 6 & .NET 8 Support

As you may be aware, Microsoft officially discontinued .NET 6 support for .NET MAUI back in May. We are announcing that our plans align with this change, and we will be ending our support for .NET MAUI in .NET 6 in November—this should give you extra time to get off .NET 6 and onto .NET 7/8.

This transition marks an exciting milestone as we prepare to welcome the arrival of .NET 8, which will bring a host of new features and enhancements. Rest assured that during this period, we are actively working to ensure a seamless transition and guarantee an official and robust support system for .NET 8, which we will be ready to launch alongside its official release.

Check out the Detailed Release Notes

To get an overview of all the latest components, features and improvements we’ve made, check out the release notes for the product: Telerik UI for .NET MAUI (Release Notes).

Telerik UI for WPF

RadSlideView and RadPipsPager components

RadSlideView is a flexible navigation control that allows you to slide between different views, thus providing an interactive navigation. With it, you can build a gallery display to show your images and content efficiently.

RadPipsPager lets the user navigate a linearly paginated collection using glyphs also known as pips.

The two controls work seamlessly with one another to enhance the navigation experience in your applications.

They also share some of their main features:

Navigation: The controls allow you to navigate through the data either in a loop or from end to end.
Orientation: They can be oriented vertically or horizontally.
Customizing navigation buttons: The navigation buttons can be easily customized.

You can find more information about the new components in their respective documentation sections:

Windows 11 Compact Theme

Get ready to elevate your app’s aesthetics and create a masterpiece with the most innovative addition to the R2 2023 Release—a new, high-density (or compact) layout option for the Windows 11 theme. Designed for information rich UI and similar specialized scenarios, this new theme mode brings a stunning and sleek look to your WPF apps.

While functionality and behavior have not changed and remain consistent across the two size and density options, the default heights and offsets have been updated for all controls to support both density options.

For more information on getting started with our latest theme, visit the Telerik UI for WPF theme documentation.

RadDocking: Move Panes Between Multiple Docking Instances

No more moving pane restrictions between docking instances. Users can now create a group of dockings in which moving and docking panes are not limited, no matter if dockings are nested or side by side. This enables powerful UI rearrangement abilities in applications with multiple dockings in a single view.

For more information on getting started with this powerful feature, visit the Telerik UI for WPF RadDocking documentation.

SyntaxEditor: Search UI Enhancements

To better cover well-known scenarios in text or code editing from VisualStudio or NotePad++, we added more search options in the search panel. MatchCase, MatchWholeWord and Regex settings will give your users the powerful search experience they expect.

RadPivotGrid LocalDataSourceProvider Hierarchies

The LocalDataSourceProvider now allows you to display nested properties of the objects in its ItemsSource in a hierarchy similar to how DateTime properties are visualized in the RadPivotFieldList.

Nested properties can be utilized to create a report in the same manner as non-nested ones.

You can enable this functionality by setting the new EnableHierarchy property of the LocalDataSourceProvider to True. Then you will be able to provide a nested property path as the PropertyName of a group description.

To see this in action, check out the PivotFieldList demo in the WPF Examples application.

Here is also a list of other popular features we updated for you in this release:

TreeView: Ability to perform selection on mouse up
GridView: ExactMatch functionality in search-as-you-type feature
PropertyGrid: Allow searching for property fields that are not expanded initially

Support for .NET 8 Preview

We are excited to announce that we are extending our support to include the preview versions of .NET 8. While .NET 8 is still in the preview phase, we understand the eagerness to explore its capabilities. We have thoroughly tested our components and have made sure they are compatible with the latest preview releases.

Telerik UI for WinForms

The R2 2023 release comes with a brand-new Heat Map control, a dark Visual Studio 2022 theme, modernized Scheduler appointments, LineNumbering in the RichTextEditor and a ton of other improvements.

Heat Map

RadHeatMap is here to help you visualize numeric data in a meaningful and straightforward way. It uses a two-dimensional layout with indicative colors to represent data. Each entity is represented by a colored rectangle and the applied color maps to the magnitude of its numeric value. At a glimpse, you can spot trends and easily compare different data items.

The component comes with many features like intuitive API, databinding, unbound mode, different colorizers, labels, selection, tooltips and screentips, and custom painting.

For more information on getting started with the HeatMap control, visit the WinForms HeatMap documentation.

Visual Studio 2022 Dark Theme

Yet another member of our family of dark themes is coming. We are expanding this collection because we know that many of you are fans of the dark side. As its name suggests, the theme is inspired by Visual Studio 2022 and its dark mode.

For more information on getting started with our latest theme, visit the Telerik UI for WinForms themes documentation.

Scheduler Appointment Styles

We’ve always strived to create modern components and designs. It was about time for the RadScheduler look to completely change. New appointment styles are coming to RadScheduler—they are fresh, bold and modern. The styles vary from one theme to another, matching its general look and feel.

Line Numbering in RichTextEditor

RadRichTextEditor has a new handy feature—line numbers. The numbers are displayed at the beginning of each line and, if needed, can work independently in different paragraphs, sections or pages. They are quite popular in legal documents, scripts or medical records.

For more information on getting started with this powerful feature, visit the WinForms Line Numbering in RichTextEditor documentation.

Support for .NET 8 Preview

.NET 8 is still in preview but it’s getting increasingly stable. We’ve also played with this new runtime and so far, could not isolate issues with the components. If you are adventurous enough or want to experiment, Telerik UI for WinForms has you covered.

Other Improvements

Besides the highlights above, the 2023 R2 release comes with plenty of other enhancements. I will name just a few that will improve your Telerik UI for WinForms experience:

Major performance gains in our Visual Studio extensions. Now we are using new APIs allowing us to offload the UI thread. This is an ongoing effort, so expect more in this regard with our next releases.
We’ve decided to update our distribution with assemblies that are digitally signed. So, if you need those, now you can download them straight from your Telerik account.
Many fixes and improvements related to importing, printing and copying documents inside the RadRichTextEditor control.

Telerik UI for WinUI

New TimeBar Component

RadTimeBar is a time-bound DataVisualization control. Its chief purpose is to allow lightweight scrolling and navigation through large periods of time. Additionally, the control exposes intuitive API which allows for both declarative and programmatic manipulation of the control.

The component provides the following features:

Intervals: The control allows you to define the available intervals that will be visualized when you zoom in/out on the control.
Selection: A time interval can be easily selected via the mouse or by setting a couple of properties of the control.
Special slots: This feature can be used to highlight different time intervals in the control.
Custom intervals and formats: The intervals can be customized by implementing a couple of interfaces. This way you can modify the intervals and the date-time formats used to define the appearance of the periods.
Localization: As all controls in the suite, the RadTimeBar supports several languages. The strings that are localized are the date labels (month, week, etc.).

For more information on getting started, visit the Telerik UI for WinUI TimeBar control documentation.

Telerik UI for Xamarin

In the R2 2023 release, our main focus revolved around Telerik UI for .NET MAUI. However, we are delighted to share that we fulfilled one of the most highly requested features for our Xamarin’s DataGrid component.

Xamarin DataGrid Enchantment: Empty Template Support

This powerful addition allows you to effectively communicate with end-users when the DataGrid control contains no data to display. By utilizing the Empty Template feature, you can provide informative and visually appealing messages (or even images!), enhancing the user experience and ensuring clarity.

Telerik Document Processing Libraries

With the highly anticipated R2 2023 release, we are thrilled to present a plethora of enhancements that span the entire suite. Let’s dive into the highlights of the Telerik Document Processing Libraries, where exciting improvements await:

In the latest update, the PDF Processing library introduces a valuable addition: an image compression setting. This setting empowers you to define the desired compression level when exporting images. You now have the flexibility to choose between Default, None and FlateDecode compression options, ensuring optimal output quality.

Moreover, we are pleased to announce a new default implementation for the ImageUtils’ JpegImageConverter and ImagePropertiesResolver, leveraging the powerful capabilities of the SkiaSharp library.

New SpreadStreamProcessing Improvements: Support for Importing Rich Text as Plain Text

Now, you have the ability to import rich text and seamlessly extract it as plain text, eliminating any formatting elements. This enhancement simplifies your data processing workflows, allowing you to focus solely on the textual content. Say goodbye to complex formatting concerns and embrace the ease of extracting and working with plain text using the SpreadStreamProcessing library.

Document Processing Libraries: Fixes and Quality Improvements

In the R2 2023 release, the Document Processing team prioritized an extensive range of bug fixes, aiming to deliver a higher level of quality for the library and enhance overall performance. There were 20+ bug fixes in the PDF Processing library alone.

Join Us for Release Webinar (and More)

Progress Telerik .NET Web, Desktop & Mobile Products R2 2023 Release Webinar | June 8

Discover all updates across Telerik UI for Blazor, UI for ASP.NET Core, UI for ASP.NET MVC, UI for ASP.NET AJAX, UI for WPF, UI for WinForms, UI for WinUI, UI for .NET MAUI and UI for Xamarin and ThemeBuilder.

Save Your Seat

Join Us on Twitch

Join the  Livestream Release Party on release day, June 7, 11 a.m. – 12:30 p.m. ET to hear the release news and hang out with dev friends.

The live webinars and Twitch sessions are a great opportunity for you to ask questions before and during the webinars. We’ll be waiting to hear from you on Twitter—just use the #heyTelerik and #heyKendoUI hashtags. Another great option is the live chat during our release session on CodeItLive, our Twitch channel.

What’s New in Telerik Desktop & Mobile with R1 2023

2023-01-18T15:41:44Z

We’re excited to share about our R1 2023 release update for our Progress Telerik products for mobile and desktop. Keep reading!

Telerik UI for WinForms

Hey, hey, hey! WinForms is here! With the R1 2023 release, our Telerik UI for WinForms suite grows stronger—from two new controls and a new theme to new functionalities. We are also happy to share that with this official release of Telerik UI for WinForms, .NET 7 is fully supported. Cool, right?

Now, let’s bring more light to the new goodies which come with R1 2023 release. With the current release, the team targets one of the most important obstacles every developer must overcome: designing a functional interface.

We will start with the new controls, which I think will bring a smile to your face.

Windows 11 Theme

New year, new controls, new look. To be up to date with the latest fashion trends and to look shiny as hell, let’s welcome Windows 11 theme to the Telerik UI for WinForms suite. To see how cool it looks, you can check it out in our Theme Viewer tool, where you can also see all other themes included in Telerik UI for WinForms package.

ToolbarForm

Saving space in large applications is crucial for being user-friendly and staying competitive in the market. The RadToolbarForm extends its non-client area and allows adding various UI elements: buttons, dropdown menus, text boxes and more. The title bar is separated into three sections which can be populated with different controls per your requirements. You can use this form to create modern apps like Visual Studio, Microsoft Word or Excel, Outlook, etc.

TaskbarButton

Let me share a secret with you. You can use the taskbar for more than seeing your apps and checking the time.

The RadTaskbarButton component allows you to interact with the Windows Taskbar and gives developers the proper API to define the style for their application’s taskbar button.

By utilizing the taskbar, you can give the end user a shortcut to your application’s internal commands or show a loading indicator when the application is loading or a long running task is currently in progress.

There are other functionalities like showing a badge on the taskbar icon to show the current status of the application, modifying the jump list by adding shortcuts to other related applications, etc.

These functionalities are only part of the API which you can use. I think you know where you can read more about them, but still I will give you a hint: In our RadTaskbarButton Online Documentation.

Don’t leave your taskbar application icon hanging on the screen like you don’t know what to do with it. Show them that they are wrong!

If you think that is all, let us check some of the other perks.

SyntaxEditor: Word Wrapping

SyntaxEditor control is a great text editor tool which provides built-in syntax highlighting and code editing experience for popular languages. What was missing so far was word wrapping functionality. What is a text editor without word-wrap?

This release, we add this functionality to the control. When the feature is enabled, the horizontal scroll bar is removed, and all the text is horizontally fit in the available space.

We have also included an additional margin that holds the icons and can be removed if needed. I’m sure you have seen this view mode in many editors and IDEs, so I hope it will make your WinForms applications which use our RadSyntaxEditor more useful and user friendly.

To see how to use this functionality, please check the Word Wrap article from the SyntaxEditor help documentation.

.NET 7 Support

During the last year, we’ve implemented and shipped support for the various preview versions of .NET 7. With this release, we are shipping support for the official version of .NET 7. This is the first major release which fully supports .NET 7.

Also, we have removed the .NET 5 support with the .NET 7 introduction, so please consider upgrading your .NET 5 applications to newer .NET. With the R1 2023 release, DLLs targeting .NET 5 will not be available for download from your account nor the NuGet package for .NET 5.

Revamped Icons

The new release and the new theme brought a new glyph font—the TelerikFluentIcons. It contains a similar set of icons to the TelerikWebUI but with a different visual appearance to better match the Windows 11 iconography. The glyphs have been redesigned to embrace a softer geometry and more modern metaphors.

WinUI

Find out what’s new in Telerik UI for WinUI 2.4.0!

Calculator

Announcing the brand-new Calculator control for WinUI! I guess there is no need to explain in detail what Calculator is?! However, let’s say couple words about it. RadCalculator is a useful component that enables your users to perform calculations directly in the WinUI application, without navigating to a different app. The control has an easy-to-use interface providing all basic calculations such as addition, subtraction, multiplication and division, as well as some more complicated ones—reciprocal, square root, negate. Furthermore, all the Memory and Clear features are exposed as well.

Check out the key features below:

Basic calculations — addition, subtraction, multiplication, division
Additional calculations — negate, square root, reciprocal
Memory functionality
Clear entry, clear all, delete functionality
Customized functions
UI automation support

For more information about the control, make sure to check out the Calculator section in our online help documentation.

CalculatorPicker

RadCalculatorPicker is an additional component that provides a quick way to show and use RadCalculator in scenarios where saving space is important. One very useful use case would be to use the Calculator as editor of the cell value of DataGrid (as seen in the screenshot above). I’m sure you will make good use of it! For more details, check out the CalculatorPicker article in our help documentation.

.NET 6 and Windows App Sdk 1.2 Support

With this release we are removing the .NET 5 support and adding .NET 6 with Windows App SDK 1.2 support. So, if you are still on .NET 5, make sure to migrate to .NET 6. And if you have any issues with migration, do not hesitate to contact us.

Check out the Detailed Release Notes

We have a lot more! To get an overview of all the latest features and improvements we’ve made, check out the Telerik UI for WinUI (Release Notes).

Telerik UI for WPF

Let’s take a look at what’s new in Telerik UI for WPF with R1 2023.

OfficeNavigationBar

Our brand new OfficeNavigationBar component is inspired by the MS Outlook Navigation Bar. It allows you to easily navigate between different views and offers the ability to quicky access a minimalistic subset of a view within a popup window.

Here are some of the features it provides:

DisplayModes – compact or full mode
Navigation Options Window – allows controlling the order and maximum number of visible items, switching between display modes
Peek Window – displays a callout over the selected item (or item under mouse) which can host additional info or UserControls (views) associated with the item

For more information about the control, make sure to check out its online help docs.

Map: Vector Tiles Support

We are glad to announce that the most voted Map feature in the latest years—support for vector tiles—is now here!

Vector data consists of mainly geometry and text definitions which is rendered on the client. All data is separated in layers and every layer can be styled with style definition located in JSON file referenced in your application. This brings a new level of flexibility and customization options, allowing users to create various map appearances.

The new map feature consists of several new providers allowing connection to online vector tile services or rendering local vector data:

MapBoxMapProvider – connects to online MapBox vector tile service via access token
MbTilesMapProvider – renders local mbtiles data (sql archives which may contain both vector and raster tile layers)
UriVectorTileMapProvider – renders data from local pbf/mvt vector tile files
VectorTileMapProvider, VectorTileMapSource, IMapStreamProvider – base public classes / interfaces for developing custom vector providers

Vector tiles are generally a great opportunity to enrich, customize and provide a modern look to your mapping applications, so we would love to hear any feedback you may have on the matter. Please drop us a line about how it goes when you integrate them.

ScheduleView: Improve Performance with a Lot of Resources

This release, we added a highly requested improvement in the rendering of the resource group headers. They are now virtualized, and this enables a smooth user experience, especially when resources come in hundreds or thousands.

You can enable the feature by setting the IsGroupHeadersVirtualizationEnabled property to true.

Previously such heavy UI resulted in thousands of UI elements rendered on load, but now only the resources, special slots and appointments visible in the viewport are generated, allowing smoother scrolling experience.

To get into more details regarding this feature, you can visit its documentation article.

RichTextBox: New Selection Mode

The new selection mode allows you to select whole words similarly to Microsoft Word. It can be enabled by setting the IsAdvancedSelectionEnabled property. The following GIF shows how this works.

PivotGrid: Load Data from OLAP Cube on Demand (Lazy Loading)

The new load on demand feature will increase the performance of your OLAP-based PivotGrid scenarios. It allows you to fetch the needed data only when the associated group gets expanded.

By default, the OLAP data providers (XmlaDataProvider and AdomdDataProvider) will pre-load all the data from the associated cube and display it in the PivotGrid. To change this behavior, set the EnableLoadOnDemand property of the data provider to true.

ChartView: Create Histogram Charts with ScatterRangeBarSeries and ChartHistogramSource

With the new ScatterRangeBarSeries and the ChartHistogramSource, you can now create histogram charts. These types of charts are generally used to visualize continuous data, measured in two directions (values). It is, however, just a use case of the ScatterRangeBarSeries which can handle non-continuous data sets too. Here is a quick set up of a sample scatter range bar chart:

First, we give some data via ScatterBarInfo instances:

public MyUserControl()  
{  
    InitializeComponent();   
 
    var source = new ObservableCollection<ScatterBarInfo>(); 
    source.Add(new ScatterBarInfo(0, 4, 8, 10)); 
    source.Add(new ScatterBarInfo(6, 10, 1, 6)); 
    source.Add(new ScatterBarInfo(1, 1.5, 1, 6.5)); 
    source.Add(new ScatterBarInfo(3, 3.5, 4, 5)); 
    source.Add(new ScatterBarInfo(8, 11, 7, 11)); 
    this.scatterRangeBarSeries.ItemsSource = source;  
}

Then we bind the data via four major range-definition properties:

<telerik:ScatterRangeBarSeries x:Name="scatterRangeBarSeries"  
                  HorizontalLowBinding="HorizontalLow"  
                               HorizontalHighBinding="HorizontalHigh" 
                               VerticalLowBinding="VerticalLow" 
                               VerticalHighBinding="VerticalHigh" 
               ItemsSource="{Binding}" />

Please follow the databinding help section to get into more details on how to populate the scatter range bars with data in a MVVM way.

End of .NET 5 Support

As you may know, since May 2022 .NET 5 is out of Microsoft support. Being up to date with the current technology trends, from this release on, we will no longer support .NET 5. This includes assemblies, NuGet packages VS extensions. We generally encourage you to switch your apps to .NET 6 and .NET 7 (you know we have Day-Zero, support for .Net7, right ?) in the near future.

However, if this sounds pressing to you, you can consider using .NET Core 3.1 which we will still ship for several releases (until .NET 8 is released).

Other Features

Common: Added ValidationErrorTemplateHelper.DisplayMode supporting different kind of visualizations of the error message.
ChartView: Added API for showing empty content between the axis when there is no data.
ComboBox: Added option to select partial matches.
Diagrams: Exposed constant to control minimum distance for which snapping next to shapes is enabled during connection manipulation.
GridView: Added GridViewAlternateRowStyle which can be used for setting an alternating row background.
GridView: Implemented an option to change the default number of distinct values shown by setting the DefaultDistinctValuesCount property.
RichTextBox: Introduced support for East Asian Font attribute when exporting Run fonts.
TabControl: Added option to allow inverting the scroll direction when using the mouse wheel over the tab strip panel.

Check out the Detailed Release Notes

We have a lot more! To get an overview of all the latest features and improvements we’ve made, check out the release notes for the products below:

Telerik UI for WPF (Release Notes)
Telerik UI for Silverlight (Release Notes)

Telerik Document Processing Libraries

The R1 2023 release brings numerous improvements across the entire suite. Here are some of the highlights of the Telerik Document Processing Libraries:

New Encryption Mode Supported in RadPdfProcessing Library

We have added support for the Encryption Algorithm 5 with AES-256, which was one of the most demanded features. Here are the currently supported algorithms:

Supported encryption algorithms for import : RC4 (V2), AES-128 (AESV2), AES-256 (AESV3)
Supported encryption algorithms for export: RC4 (V2), AES-256 (AESV3)

The encryption algorithm is controlled by the EncryptionType property of the export settings. Detailed information is available here: Export settings.

New Search API in the RadPdfProcessing Library

The new search API allows to search for a specific text in the PDF files. It has many methods that allow you to customize the search criteria and even search with regular expressions. The search result returns the page and the location of the searched text. Here is a small example that shows this:

var search =  new  TextSearch(document);
var result = search.FindAll("Lorem",  TextSearchOptions.Default);

Detailed information about this functionality is available in our documentation: Search.

New Fields in RadWordsProcessing

We have added table of contents fields TOC and TC, which allow you to dynamically add a table of contents to your documents using various switches.

The table of authorities fields—TOA and TA—are now supported as well. These fields allow you to add a table of authorities to your document.

In order to make the TOC and TOA fields work, we have added the Sequence field as well.

Our demo application now has an example of these fields.

You can see all supported fields in our documentation as well: Fields Overview.

Telerik UI for .NET MAUI

R1 2023 brings exciting updates to Telerik UI for .NET MAUI, including five brand-new controls—ToolBar, ImageEditor, SignaturePad, ProgressBar and Accordion. We’ve also added some enhancements to our powerful DataGrid control. Let’s have a sneak peek at the most interesting stuff we have for you in this release.

In today’s world of mobile and desktop apps, it’s important to have a clear and easy-to-use navigation system. That’s why we’re excited to introduce our new Toolbar component for .NET MAUI! This powerful and versatile component allows you to easily create a sleek and professional navigation experience for your app. It can mimic the functionality and behavior of the Visual Studio toolbar with its Strip and Overflow areas.

Here are some of the key features you get in the new ToolBar control:

Rich collection of toolbar items: navigation button, split button, slider, listpicker, radio buttons and more.
Support for adding text and image to the toolbar item.
Horizontal or vertical orientation: RadToolbar supports both horizontal and vertical orientation.
Overflow menu: when the toolbar items cannot fit in the available space, an overflow button is displayed. The items are added in the overflow menu. You can display them using the different modes of the overflow menu.
Panning and scrolling through the Toolbar items.
Options to separate the toolbar items through UI element part of the toolbar items—SeparatorToolbarItem.
Options to group the toolbar items.

Visit our product documentation for more information on getting started with the Telerik UI for .NET MAUI ToolBar control.

.NET MAUI ImageEditor

You can now easily visualize and edit images in different file formats in your mobile and desktop application with our new ImageEditor control for .NET MAUI. The component comes with convenient image interactions such as zoom and pan, flip and rotate, resize and crop.

It is also packed with a variety of filters which allows you to perform various color adjustments to the image such as adjusting the Hue, Saturation, Brightness and Contrast. If your users are unhappy with an image interaction or the set of interactions, they can go back and forth because the ImageEditor has History support.

Here are some of the key features you get in the new ImageEditor:

Importing and exporting images: The control allows you to import different image formats such as JPEG, PNG, GIF, BMP, and export images in JPEG, PNG, GIF, BMP formats.
Various image source options: Load images from a Stream, File (as embedded resource, or image located on the device) and URI.
Support for undo/redo and reset: RadImageEditor has a history stack with the changes applied to the image. This means that you can reverse and re-apply actions.
Support for Interactive Pan and Zoom: The control has built-in pan and zoom functionality that will help you interact with the image and display it in a convenient way.
Built-in Toolbar: the control comes with a ready-to-use toolbar pre-populated with all the items needed to manipulate images.
Custom Toolbar: RadImageEditor’s Toolbar can be fully customized. You could populate the toolbar with the ToolbarItems needed for editing the image.
Commands support: The control provides built-in commands and interactive commands. In addition, there are Toolbar commands.
Support for Image Transformations:
     ◦ Crop
     ◦ Resize
     ◦ Rotate—Left and Right
     ◦ Flip—Horizontal and Vertical
Built-in Filters:
     ◦ Hue
     ◦ Saturation
     ◦ Brightness
     ◦ Contrast
     ◦ Blur
     ◦ Sharpen

Visit our product documentation for more information on getting started with the Telerik UI for .NET MAUI ImageEditor control.

New SignaturePad Control for .NET MAUI

The Telerik SignaturePad control for .NET MAUI is a user-friendly component that allows you to capture and save signatures within your native mobile and desktop applications.

Upon interacting with it, the component displays the signature path, ensuring that your end user feels a natural pen effect. You can easily customize signature’s stroke and color and save the signature as PNG or JPEG.

Here are some of the key features of the SignaturePad control:

Configure the stroke thickness and stroke color of the signature to achieve the desired look.
Exhaustive number of events that are raised when a new stroke is started, completed and an event fired when the surface is cleared.
Commands Support: Easily clear the signature from the surface using the exposed command.

Visit our product documentation for more information on getting started with the Telerik UI for .NET MAUI SignaturePad control.

RadProgressBar for .NET MAUI

If you need to indicate the progress of a long-running operation in your desktop or mobile application, then our RadProgressBar comes in handy. It can also show multiple forms of progress, such as data loading or a multi-step user action, in which you can visualize how much has been completed and what remains.

Here are some of the key features you get in the new ProgressBar component:

Value and Progress: Used to set and report the progress of a task inside the ProgressBar control.
Value range: Define value ranges by setting the minimum and maximum values.
Different value display modes: The label that shows the current state of the progress can be set to absolute value, percent, text or fully hidden.
Segments support: RadProgressBar can be divided in segments.
Indeterminate mode support: A mode that displays an animation indicating an unspecified amount of waiting time.
Different animations: You can apply different animation easing and animation duration while changing the value of the ProgressBar.
Flexible styling API: For customizing the progress fill, track fill, indeterminate fill, label text color, font size and more.

Please visit our product documentation for more information on getting started with the Telerik UI for .NET MAUI ProgressBar control.

UI for .NET MAUI Accordion

RadAccordion is a powerful and versatile component that allows you to easily organize and present large amounts of content in a small space. With its intuitive and user-friendly interface, you can quickly and easily expand and collapse sections to view the information you need.

Collapsed/expanded states: RadAccordion consists of AccordionItems that can host any content. The end users could show or hide this content by interacting with the headers of the control.
Collapse All Items: You can allow your app users to collapse all items of the RadAccordion.
Highly customizable items: You have full control over the visual appearance of the Accordion items—you can customize the border style of each item, the border style of items’ headers, as well as the indicator text, font, size, location and color.
Animation while expanding/collapsing: RadAccordion provides slick customizable animation played while the expandable content is expanded/collapsed.

Visit our product documentation for more information on getting started with the Telerik UI for .NET MAUI Accordion control.

New Feature in DataGrid—Frozen Columns

This powerful feature allows you to “freeze” or “pin” certain columns of your DataGrid so that they remain visible and in place even as the user scrolls through the rest of the columns. This is particularly useful when working with large and complex datasets, as it allows users to easily reference important information while scrolling through the rest of the data.

Telerik UI for Xamarin

With R1 2023 our main focus was on Telerik UI for .NET MAUI; however, we were able to deliver two of the most requested features for UI for Xamarin.

Xamarin DataGrid Enchantment: Support for Scrolling to a Specific Item

Our DataGrid for Xamarin just got a new API that enables you to programmatically scroll a DataGrid so that a specific item is visible on the screen, thus bringing a smoother user experience into your Telerik UI for Xamarin app.

Here is an example of how to scroll to the last item in the DataGrid by using the new ScrollItemIntoView method (the code executes on a button click):

private void Button_Clicked(object sender, System.EventArgs e)
{
    var item = this.vm.Clubs[this.vm.Clubs.Count - 1];
    this.grid.ScrollItemIntoView(item);
}

Visit our product documentation for more information on the Telerik UI for Xamarin DataGrid control ScrollItemIntoView method.

New Functionality in our SideDrawer Component for Xamarin

By default, the SideDrawer Drawer Content area closes when user clicks/taps outside of it. With R1 2023, you can control that behavior by setting using the TapOutsideToClose boolean property. Its default value is True, but when setting it to False, the drawer content area of the component remains open if the end user taps/clicks outside of it and the main content area remains active. Here is it in action:

Visit our product documentation for more information on the Telerik UI for Xamarin SideDrawer control TapOutsideToClose property.

Head over to the Telerik page and download a free trial. If you are an active license holder you can grab the latest and greatest from the “Your Account” page or update your NuGet package reference to the latest version directly in your .NET solutions.

Share your thoughts with us on our feedback portal and help us shape the future of Telerik UI!

Join Us for Release Webinar (and More)

Progress Telerik .NET Web, Desktop & Mobile Products R1 2023 Release Webinar | January 26

Discover all updates across Telerik UI for Blazor, UI for ASP.NET Core, UI for ASP.NET MVC, UI for ASP.NET AJAX, UI for WPF, UI for WinForms, UI for WinUI, UI for .NET MAUI and UI for Xamarin and ThemeBuilder.

Save Your Seat

Join Us on Twitch

If you can’t wait until the webinar to unpack the new release, join the Livestream Release Party on January 19, 10 a.m. – 11:30 a.m. ET to hear the release highlights across the entire Progress Developer Tools portfolio and hang out with friends.

And for those of you who will be at NDC London on January 25-27, you are welcome at the Progress booth where we can talk about all product developments and the latest release.

Progress Kendo UI R1 2023 Release Webinar | January 31

Discover all updates across KendoReact and Kendo UI for Angular, Vue and jQuery, as well as ThemeBuilder.

Save Your Seat

Progress Telerik Reporting, Mocking and Debugging Tools R1 2023 Release Webinar | February 2

Discover all updates across Telerik Reporting, JustMock, Fiddler Everywhere and Fiddler Jam.

Save Your Seat

Master .NET Object Inspecting With the WinUI PropertyGrid

2022-10-19T07:34:00Z

Looking for an easy and versatile approach for processing the properties of any .NET object with the help of automatically generated built-in editors? All that plus the support for nesting and customizing the property definitions, and, of course, the capability to keep it all organized. You got it.

Ahoy, .NET lovers! How many instances of Visual Studio do you have running right at this moment? I bet it’s not just one, and I bet the Properties view is one of the things you use at least once a day. Yes, this one:

Wanna have it in your WinUI apps, too? Well, step aside and make some noise as the PropertyGrid comes through! Let’s examine the brightest star of the Telerik UI for WinUI’s 2.2.0 release together.

What To Expect?

An easy and versatile approach for processing the properties of any .NET object with the help of automatically generated built-in editors. Support for nested properties, as well as ability to customize the property definitions and the corresponding data editors. And last, but not least, the capability to organize the properties using sorting, grouping and filtering (searching). Read on in the next sections.

Where To Start?

You will not need any professional training before diving in the deep, but you will need a WinUI project and a reference to the Telerik.WinUI.Controls.dll assembly. And one more essential thing—a proper Item to assign to the PropertyGrid. Let’s try it out.

Here is a simple DataInfo class with various property types:

public class DataInfo
{
public int IntegerValue { get; set; }
public string StringValue { get; set; }
public bool BoolValue { get; set; }
public DateTime DateTimeValue { get; set; }
public MyEnum EnumValue { get; set; }
public ObservableCollection StringsCollection { get; set; }
}

public enum MyEnum
{
ValueA,
ValueB,
ValueC
}

What’s left is to create an instance of it and assign it to the PropertyGrid’s Item property:

this.propertyGrid.Item = new DataInfo()
{
IntegerValue = 7,
StringValue = "My String Value",
BoolValue = true,
DateTimeValue = DateTime.Today,
EnumValue = MyEnum.ValueA,
StringsCollection = new ObservableCollection() { "Collection Item 1", "Collection Item 2", "Collection Item 3" }
};

Ooops, but where is the PropertyGrid?

Eager to see what our powers of wizardry created?

If this System.Collections.ObjectModel.ObservableCollection1[System.String] annoys you, here is the cure:

public class CoolerObservableCollection : ObservableCollection
{
    public override string ToString()
    {
        return "MyAwesomeCollection";
    }
}

And then, change the StringsCollection to be of type CoolerObservableCollection. The result will be as follows:

While we’re on the collections topic, here is another bonus: collection boosters. I am talking about the CollectionEditor and CollectionEditorPicker—two components used for visualizing the items in a collection and generating editors for each property using—guess what!—the built-in PropertyGrid control.

There is one more—the CollectionNavigator—which is a component providing seamless navigation and editing of a collection, plus built-in customizable commands, predefined customizable buttons and more. Be sure to check out the CollectionEditor and CollectionNavigator sections in the help documentation.

Now, let’s get back to the property grid and extend the data a little to peek at the nest.

What’s Inside the Nest?

The first thing that got to my mind was to create a simple system permissions class:

public class SystemPermissionsInfo
{
public bool CanRead { get; set; }
public bool CanWrite { get; set; }
public bool CanModify { get; set; }
}

Shall we add that to the DataInfo?

public SystemPermissionsInfo SystemPermissions { get; set; }

And, of course, to the Item:

SystemPermissions = new SystemPermissionsInfo() { CanRead = true, CanWrite = false, CanModify = false }

Don’t forget to set the NestedPropertiesVisibility to Visible like I did, because the only nest you will see is going to be an empty one.

In the above GIF, you not only saw what’s inside the nest, but you also witnessed that the PropertyGrid allows for editing the property values displayed in the UI. You should totally check out the Editing section of the control’s online documentation to learn the tips and tricks for adjusting the editing process.

I think that a great possibility here would be to change the editor templates for the system permissions. Follow me.

Yep, I created a second instance of the PropertyGrid and changed the editors for my permissions to ToggleSwitch instead of CheckBox. See how cool it is:

The Range of Arrangement

At the very start of my blog, I listed some expectations. For all these to be met, I need to show you the range of arrangement that the property grid offers. I told you that you can organize the properties through three very common and essential operations—sorting, grouping and filtering (searching).

This is the visual structure of the PropertyGrid, but the focus is on the visual elements responsible for the above-mentioned operations. I got a great idea where you can see them all in action.

Ladies and gentlemen, this is just the First Look demo of this awesome component—there is more. Be sure to get the demos app and check the rest—it is totally worth it.

Be at the Wheel

Your feedback is very important since it helps us hear your voice and determine the direction to take with the development of the products. If you’d like to add or change something, do not stand still—share your thoughts in the comments below or use the Feedback Portal.

Plug the PropertyGrid in your WinUI app and let us know what impression it made. Existing customers can access the bits of Telerik UI for WinUI in their Telerik account. New users—follow the link below.

Try Latest Telerik UI for WinUI

What’s New in Telerik Desktop & Mobile With R3 2022

2022-09-14T14:58:06Z

Telerik Mobile and Desktop products offer expanded .NET 7 support, improved Document Processing Library features and new components!

As with every release, we are eager to share what the new updates are, so let’s jump right in! Hop to your favorite section:

What’s New in Telerik UI for WinUI 2.2.0

PropertyGrid

Announcing the RadPropertyGrid component for WinUI! The control provides an easy and versatile approach to processing data objects’ properties. Utilizing its auto-generation features and the intuitive custom editor capabilities, users will be able either to display data in a way that best fits their needs or modify it with minimal effort.

RadPropertyGrid can be bound to an item with just a single line of code, and you may start exploring or editing its properties. The proper editor controls are auto-generated—text fields for string properties, CheckBoxes for Boolean, DateTimePickers for dates, etc. In addition, PropertyGrid allows flexible manual setting and customization of editors and their layout via the standard WinUI styling and templating mechanisms. It is highly customizable, allowing the user to modify the default look in an easy and intuitive manner.

Check out the key features below:

Automatic property generation – the control generates fields to read/write all public properties of the target object
Built-in property editors – predefined editors UI for the different data types
Nested properties support
Customizable property fields – customize the property definitions and the corresponding data editors
Keyboard support
Grouping
Filtering
Data validation

For more information about the control, make sure to check out the PropertyGrid section in our online help documentation.

CollectionEditor & CollectionEditorPicker

RadCollectionEditor and RadCollectionEditorPicker are two small components used to visualize the items in a collection and generate editors for each property using the built-in PropertyGrid component. You can use the ItemTemplate of the control to specify how the items from the collection should appear. The difference between them is that the CollectionEditorPicker uses a dropdown to display the CollectionEditor.

For more details, check out the CollectionEditor section in our help documentation.

CollectionNavigator

RadCollectionNavigator is the next new control this release. A light component that provides seamless navigation and editing of a collection, it provides built-in customizable commands, predefined customizable buttons and more. For more details, make sure to check out the CollectionNavigator section from our online help documentation.

DataGrid: Export

Our DataGrid gets export support—thanks to the Telerik Document Processing Libraries that are included in the WinUI distribution. The new functionality provides methods to export the current dataset displayed in the control. You can export in a synchronous or an async manner, modify the exported data and the final document. Currently the built-in export supports the following formats:

XLS
XLSX
PDF
CSV

Hope this feature will be useful. For more details, check out the Export section from our DataGrid documentation.

RibbonView & Other: Updated Windows 11 Appearance

In this release, we did many improvements in the default styles of many controls to provide a better Windows 11 look and feel. Now I want to focus on the RibbonView control—we completely redesigned it to resemble the new Office 365 Experience! It looks totally awesome and I’m sure it will improve the overall appearance of your modern WinUI application.

Make sure to check out the controls in our refreshed WinUI examples application and play around with them.

Other Features

SideDrawer: Added DrawerOpening and DrawerClosing
SideDrawer: Introduced IsOpen property

Check Out the Detailed Release Notes

We have a lot more! To get an overview of all the latest features and improvements we’ve made, check out the release notes for the products below:

Telerik UI for WinUI (Release Notes)

Get in touch by email – drop us a line, for anything related to product or just to say hi at TelerikWinUI@progress.com
Feedback Portal – share any feature request (or bug reports) that you might have
Telerik Forums – if you need any technical assistance with the product, let us know and we will help

Get the Bits

Don’t wait—try out the latest:

Telerik UI for WinUI

In case you missed it, here are some of the updates from our previous release.

What’s New in Telerik UI for WPF With R3 2022

CircularProgressBar

Announcing our brand-new WPF CircularProgressBar component. CircularProgressBar is a control that will allow your customers to track the progress of different tasks in a circular manner. It provides many customization options that will allow you to achieve a lot of different scenarios. You have probably seen such components in many different places—from health tracking smartphone applications to automatic coffee machines. Now you can easily plug it in your Telerik WPF application as well!

Check out the list of the major features of the control below:

Segments – CircularProgressBar can be split into numerous segments to indicate different types of progress.
Color Ranges – CircularProgressBar supports defining ranges with different colors.
Determinate and indeterminate states – The determinate state shows a specific amount of the progress. The indeterminate one plays an animation of the circular progress.
Customizable content – CircularProgressBar supports complex implementation for the content of its progress.
Radius manipulation – The control allows you to customize the indicator and track inner and outer radiuses.
Angles – You can control the beginning and ending angles of the component for a more customized appearance.
Secondary progress indicator – CircularProgressBar allows you to visualize an additional progress indicator.
Indeterminate animation customization – You can modify the played animation when CircularProgressBar is in an indeterminate state.

I hope this control will be useful in various types of applications. For more information, check out our online CircularProgressBar help documentation.

PivotGrid: Configuring PivotGrid Without PivotFieldList

The most desired PivotGrid feature is finally here! It allows using the control without the additional PivotFieldList control. The new functionality provides support of all existing PivotFieldList features—directly accessible trough the UI of RadPivotGrid. Your customers will be able to filter, sort, modify the descriptions and more through the built-in dropdown menus, dialogs and buttons. The feature can be enabled by simply setting the attached FieldListBehavior.ShowInline property as shown below:

For more details, make sure to check out the Inline PivotFieldList section from our online help documentation.

SyntaxEditor: Word Wrapping

A new cool feature for the SyntaxEditor is Word Wrapping! When the feature is enabled, the horizontal scroll bar is removed and all the text is horizontally fit in the available space. We have also included an additional margin that holds the icons and can be removed if needed. I’m sure you have seen this view mode in many editors and IDEs, so I hope it will make your WPF applications more useful and user friendly.

For more info, check out the Word Wrap article from the SyntaxEditor help documentation.

ChartView: ErrorBar Series

We are adding a new ChartView series this release—ErrorBar Series! This type of series visualizes its data points using error bar shapes. The error bar shape allows you to display an error or uncertainty in the plotted data. The shape consists of a single line with caps at the two ends. An additional marker that shows the expected measure can be displayed too.

For more information about all of the setup and customization options of the new series, please check out the ErrorBar Series article from the ChartView help documentation.

Latest .NET 7 Preview Support

As always, we are up to date with the latest technology trends, and we are happy to announce that Telerik UI for WPF provides support for the latest .NET 7 Preview 7. The .NET 7 Preview binaries can be found in a separate zip archive in your account—download it and give it a try! They will be included in the NuGet packages and in full distribution once .NET 7 becomes official. Also we plan to remove the .NET 5 support with the .NET 7 introduction, so please consider upgrading your .NET 5 applications to newer .NET. (If such a change somehow affects your plans, please contact us and share more details.)

RibbonView: New Windows11 Theme Appearance

We improved the default RibbonView styling for the Windows 11 theme in order to resemble the new Office 365 Experience. Looks nice, doesn’t it?

If you want to see the theme in action, make sure to play around with our Color Theme Generator for WPF app! For more details about all the features of the Windows 11 theme, please check out this help article.

RichTextBox: Line Numbering

The latest RichTextBox feature enables you to display the appropriate number beside each line of text—this is useful for specific types of content, such as scripts, legal or medical documents. Through the intuitive API of this feature, you will be able to easily control how the numbering appears. You can change the initial number, the increment number, the distance between the numbering and the document content, and when the numbering should restart. For more information, check out the Line Numbering help article.

Spreadsheet: Repeat Specific Rows or Columns on Every Printed Page

This new Spreadsheet functionality allows you to specify a row or a column that will be repeated on every printed page. This functionality is useful when you need to print or export to PDF data spanning multiple pages and still allows the users to see the important information on the top/left side for better orientation. For more details, check out the Printing section of our Spreadsheet documentation.

Other Features

SyntaxEditor: FontWeight and FontStyle of the highlighted words
VirtualGrid: FontWeight and FontStyle of the cells
RibbonWindow: Windows 11 Theme acrylic effect now can be enabled on all Windows 11 version, not only on the preview ones

Check Out the Detailed Release Notes

We have a lot more! To get an overview of all the latest features and improvements we’ve made, check out the release notes for the products below:

Telerik UI for WPF (Release Notes)
Telerik UI for Silverlight (Release Notes)

Feel free to drop us a comment below sharing your thoughts. Or visit our Feedback Portals about UI for WPF, Silverlight and Document Processing Libraries and let us know if you have any suggestions or if you need any particular features/controls.

Try out the latest:

Telerik UI for WPF Telerik UI for Silverlight

In case you missed it, here are some of the updates from our last major release and previous Service Pack.

What’s New in Telerik UI for WinForms With R3 2022

Spreadsheet Charts

Hold up? Is that true? Yes, you read it right. Charts are coming to RadSpreadsheet control for Telerik WinForms. What could be a better improvement than visualizing your data beyond the RadSpreadsheet grid? Adding charts to a workbook can help you identify important statistics and trends in your data that may not be obvious when only looking at numbers. With RadSpreadsheet you can show charts as well as add, remove and manipulate chart objects in your spreadsheet documents.

Supported Chart Types

Different chart types give you the flexibility that your data requires. From Bar to Line, from Point to Bubble, from Pie to Area, show your users that you care. The Spreadsheet component for WinForms supports more than a dozen different types of charts allowing you to visualize categorical data, numerical data, time series data and more. You can get familiar with all supported types in the RadSpreadsheet Charts help article.

Splash Screen

What could be better to notify the end user that something big is loading than showing a splash screen form? Our newest reinforcement to the Telerik UI for the WinForms suite is here. Splash Screen allows you to display a Telerik themed control that notifies the user that the program is loading. You can customize the image of the splash screen, its animations and loading process visualization per your requirement.

If you want something more to sample, just to say “give me a second to set up the data,” we have just the things for you. Overlay and Flyout Screens will fit perfectly in a case where you want to dim the content and show the end users to be patient. You could use the Overlay Screen to show only the loading indicator. However, there could be a case where you want to notify the user that he needs to reenter his credentials to continue working on the application. In this case, Flyout Screen is what you need. The Flyout can be used to display some content over the application or be used as an interactive control. The screen can be customized in a way that you can place input controls in it, while the Overlay does not accept such customization.

Overlay

Flyout

Changes to Distribution

As of R3 2022 in Telerik UI for WinForms, the .NET 2.0 distribution is removed. From this release, the suite offers .NET 4.8 distribution. With this release, you not only get the .NET Framework projects of the Telerik source code, but .NET Core projects as well.

Bug Fixes & Improvements

Our development team managed to fix/improve more than ONE HUNDRED bugs reported by our customers. We always listen to feedback and try to produce the top-notch controls on the market.

Share your feedback with us in the Feedback Portal!

Get the Bits

Don’t wait—try out the latest:

Telerik UI for WinForms

What’s New in Telerik Document Processing Libraries With R3 2022

PdfProcessing

Export PDF pages to images: We have added the ability to convert the pages of a PDF document to images. This feature uses the SkiaSharp library. It will work with the .NET Standard version and does not depend on any Windows libraries.

WordsProcessing

Page Numbering Fields: PAGE, PAGEREF, NUMPAGES, SECTIONPAGES and SECTION fields are now supported in our library. These are commonly used fields for inserting page numbering. We have added the ability to update the field values as well.

Shapes support: With this release, we have enabled users to preserve the shapes when importing and exporting a DOCX document. We will continue working on extending the functionality to allow you to insert and manipulate these objects in the next releases.

SpreadStreamProcessing

SpreadStreamProcessing Import: We have added support for reading XLSX and CSV files. This functionality allows you to easily get the data from large files without loading the entire document in the memory. It has great performance as well.

SpreadProcessing

Repeat specific rows or columns on every printed page: This feature allows you to specify a row or a column that will be repeated on every printed page.

What’s New in Telerik UI for .NET MAUI With R3 2022

Aloha, and welcome to another Telerik UI for .NET MAUI release! In addition to the mandatory support for the latest version of .NET MAUI, we are now shipping three brand-new controls as part of our growing Telerik UI for .NET MAUI suite—DataForm, AutoComplete and Expander components! We’ve also added many enhancements to our powerful DataGrid control. Let’s have a sneak peek at the most interesting stuff we have for you in this release.

Latest .NET MAUI & Visual Studio 2022 Support

We follow the Microsoft release cadence closely and have consistently offered early support for all new .NET MAUI versions—including Day-Zero support when the framework was released in General Availability. Since then, cross-platform developers have been able to use Telerik UI for .NET MAUI, the most comprehensive cross-platform development UI library on the market, together with the latest .NET MAUI features and fixes: an unbeatable combination.

Moreover, with .NET MAUI tooling getting formal support in Visual Studio 2022 17.3, Telerik UI for .NET MAUI is now also tightly integrated with the latest VS version. Developers can also take advantage of dedicated Visual Studio Extensions with .NET MAUI templates for project creation and a UI Toolbox.

.NET MAUI DataForm

I’d like to introduce you to the new DataForm control in Telerik UI for .NET MAUI. This powerful control helps you to automatically create a form for collecting or editing data. For example, using the RadDataForm, you can easily create form-over-data UI for both mobile and desktop, like these:

Desktop:

Mobile:

The component supports different commit modes, allowing you to commit property values one by one or to commit the whole form at once. It’s also very easy to add validation to your forms and group UI elements to make large forms more manageable.

With the DataForm control, you can not only build the needed UI by using the rich set of editors that are provided out of the box, but you can easily customize those forms through the flexible styling API.

Here are some of the key features you get in the new DataForm:

Built-in editors: The DataForm provides a set of built-in editors for the available primitive types such as numeric, string, boolean, enumerations, DateTime and TimeSpan. The control detects the types of the data object’s properties and automatically displays the appropriate editor.
Validation support: You can use the built-in validation support that gives you full control over the data collected through the control.
Commit modes: DataForm provides editing support with three types of commit modes to determine when the edited value should be synchronized with the business object.
Grouping support: This allows you to easily group the form’s editors.
Data Annotations support: You can decorate the data models using Data Annotations attributes which specify validation conditions to be applied to a specific field in the DataForm. You can use different annotations like Requires, DataType, Display, RegularExpression and more.
Different layouts: You can arrange the editors and the groups by using different layouts such as stack, grid and more.
Commands support: You can execute your validation logic or commit/cancel all pending changes in the form by using the built-in commands for these actions.

Visit our product documentation for more information on getting started with the Telerik UI for .NET MAUI DataForm control.

AutoComplete Joins the Family

The AutoComplete component is a popular control for various mobile and desktop applications and use cases. Especially useful when you have to display a long, predefined list to choose from, such as a list of airports or a list of known recipients. Your app users expect this in modern apps, and now you can deliver it out of the box.

Some of the main features of the .NET MAUI AutoComplete are:

Tokens support: You can enable the users of your application to search for and select several items from the source of the AutoComplete. These items appear as tokens that can easily be deselected using their close button.
Filtering options: You can define the filtering behavior to display all the matches that either “StartsWith” or “Contains” the typed symbols.
Different suggest modes support: RadAutoComplete exposes three different modes (Suggest, Append, SuggestAppend) for providing suggestions.
Placeholder: This is used to give guidance to the end user on what should be entered in the text input.
NoResults message: NoResults message appears in the popup used for the list of suggestions whenever the control cannot find any matching items. Read more about this here.
Visualized text formatting: You can modify the displayed details of the selected item by using DisplayTextFormatter property of AutoComplete.
Custom templates: If any of the default templates do not fit a particular scenario, you can easily define a custom template.
Highlight customization: This gives you the ability to highlight the text inside the custom template.
Nested properties support: This allows binding of a complex object to the RadAutoComplete’s TextSearchPath property.

Visit our product documentation for more information on getting started with the Telerik UI for .NET MAUI AutoComplete control.

.NET MAUI Expander

RadExpander is a flexible control that helps you save space and achieve easier navigation through your app. You can place the Expander anywhere on your page and embed any content inside the dropdown area. The Expander control also gives you control over its ExpandDirection to let you adjust the control as per your custom layout.

Here are some of the features the Expander control ships with:

Collapsed and Expanded States: The control hosts the content in an expandable container that can be easily expanded/collapsed by tapping on its header.
Animation: The RadExpander control provides a property that allows you to enable or disable the animation when the content is collapsed/expanded. If you want to enable/disable the animation, you need to use the IsAnimationEnabled property.
Customization Options: The rich API for customization of the Expander component allows you to customize the visual appearance of the control in a variety of ways. You can manipulate the Animation’s duration and easing, the header of the control and its border styles.

Visit our product documentation for more information on getting started with the Telerik UI for .NET MAUI Expander control.

DataGrid Just Got a New Grouping UI

With our latest release, our powerful DataGrid component has evolved. The new enchantment is the so-called Grouping UI.

This area is called the DataGridServicePanel and allows the user to drag and drop column headers into the panel in order to group the data in the RadDataGrid at runtime.

The user is not limited to group just a single column—they are allowed to drag several columns into the panel, or rearrange the grouping. Grouping in this manner gives the user power to control how they want to view the data and reduces the coding part for the developer.

If you want to restrict the user from grouping the data or limit the grouping to certain columns, you can do it by using DataGrid’s intuitive API for that.

More information about this feature can be found in DataGrid’s product documentation.

DataGrid Footers

Column Footers
The new addition to the DataGrid control—the Column Footers functionality—allows you to display additional information which applies to the columns in a specific row placed at the bottom of the control. This row consists of individual footer cells for each column. It is of type object, so you are not limited to just using plain text in it.

By default, column footers are hidden, so if you want to make them visible you have to set the DataGrid’s ShowColumnFooters property to True.

More information about this feature can be found in DataGrid’s product documentation.

Group Footers
DataGrid exposes the Group Footers feature, which provides the option to render a footer under each group in the data grid component. Group footers contain footer cells that correspond to data columns and can display group summaries.

This footer row is also hidden by default. If you want to take advantage of this feature, you will have to enable it by setting the ShowGroupFooters property of the DataGrid to True.

More information about this feature can be found in DataGrid’s product documentation.

DataGrid Aggregate Functions

There are situations when displaying numbers in the DataGrid in which users would like to be able to see the results from aggregate calculations at the bottom of the DataGrid’s groups or columns. Now, this can be easily achieved with the new addition to the DataGrid control—aggregate functions support. It allows you to display aggregated information for the data in the column’s footer, in the group’s header or in the group’s footer.

DataGrid offers built-in support for the most popular aggregate functions: Average, Count, Sum, Min, Max and Count. All you need to do is to add a PropertyAggregateDescriptors into DataGrid’s AggregateDescriptors with the needed function:

<telerikGrid:RadDataGrid>
  <telerikGrid:RadDataGrid.AggregateDescriptors>
    <telerikCore:PropertyAggregateDescriptor  PropertyName="Points" Function=
                                            "Average"/>
                                                telerikGrid:RadDataGrid.AggregateDescriptors>
                                                telerikGrid:RadDataGrid>

If you have a more complex scenario, you are also covered—there is an option for creating a custom aggregate function by using a DelegateAggregateDescriptor.

More information about this feature can be found in DataGrid’s product documentation.

If you’re interested in starting to play with .NET MAUI, or if you’re already actively working with .NET MAUI to develop applications, I encourage you to check out Telerik UI for .NET MAUI.

To get the bits, you just need to sign up for our free 30-day trial, which gives you access to the components as well as our legendary technical support. Head to the Telerik UI for .NET MAUI overview page or click the button below and sign up for a trial today!

Try Telerik UI For .NET MAUI

Please share your feedback, ideas and suggestions, either by commenting below or by visiting our Feedback Portal about Telerik UI for .NET MAUI. Let us know if you have any suggestions and submit your features/controls requests.

What’s New in Telerik UI for Xamarin With R3 2022

Xamarin DataGrid Aggregates

With the new aggregate functions in the Xamarin DataGrid, you can display aggregated information for the data in the group’s header, or in the group/column’s footer.

The new feature comes with built-in support for the most popular aggregate functions: Average, Count, Sum, Min, Max and Count. You can easily set up the aggregates by adding PropertyAggregateDescriptors into DataGrid’s AggregateDescriptors with the desired function:

<telerikGrid:RadDataGrid>
  <telerikGrid:RadDataGrid.AggregateDescriptors>
    <telerikCore:PropertyAggregateDescriptor  PropertyName="Points"  Function="Average"/>
  telerikGrid:RadDataGrid.AggregateDescriptors>
telerikGrid:RadDataGrid>

The aggregates also support multiple types of complex scenarios through the extensibility point for defining a custom descriptor—DelegateAggregateDescriptor.

Visit our product documentation for more information on the Telerik UI for Xamarin Data Grid control and Aggregates.

Xamarin DataGrid Column Footers

The new addition to the DataGrid control—the Column Footers functionality—allows you to display additional information which applies to the columns in a specific row placed at the bottom of the control. This row consists of individual footer cells for each column. It is of type object, so you are not limited to just using plain text in it.

By default, column footers are hidden, so if you want to make them visible, you have to set the DataGrid’s ShowColumnFooters property to True.

Visit our product documentation for more information on the Telerik UI for Xamarin Data Grid control and Column Footers.

Xamarin DataGrid Group Footers

With the current release, you have the ability to render a footer under each group inside the DataGrid component. The footer cells correspond to data columns and you can use them to display group summaries.

All you need to do to use this functionality is set the DataGrid.ShowGroupFooters property to true.

Visit our product documentation for more information on getting started with the Telerik UI for Xamarin Data Grid control.

New IsLooping Property Now Available for All Xamarin Date and Time Pickers

With the latest release of Telerik UI for Xamarin, you can easily stop the looping functionality in the Date, Time, DateTime, Time and TimeSpan Pickers using just a single property—IsLooping. When IsLooping is True, which is by default, the items of each spinner can loop infinitely unless that spinner is restricted to show only a subset of the available values.

Picker with disabled looping Picker with enabled looping

Visit our product documentation for more information on the Telerik UI for Xamarin DatePicker control IsLooping property.

Please share your feedback, ideas and suggestions, either by commenting below or by visiting our Feedback Portal about Telerik UI for Xamarin.

Don’t hesitate to check out the latest:

Try Telerik UI For Xamarin

Telerik .NET Web, Desktop & Mobile Products Webinar & Twitch Session

Wednesday, September 21, 2022 | 11:00 a.m. – 1:00 p.m. ET
Discover all updates across Telerik UI for Blazor, UI for ASP.NET Core, UI for ASP.NET MVC, UI for ASP.NET AJAX, UI for WPF, UI for WinForms, UI for WinUI, UI for Xamarin and UI for .NET MAUI.

Save Your Seat

Join Us on Twitch Today

Live from Devreach’22 @ Progress360: Join the live community session from the Progress360 Streaming Studio on September 14 from 10 a.m. – 11:30 a.m. ET to hear the release highlights and celebrate the DevReach spirit with us at our Livestream Release Party.

And the Best Part About the Release Webinars?

Another great option is the live chat during our release session on CodeItLive, our Twitch channel.

Mastering PDFs With the First WinUI PdfViewer on the Market

2022-06-29T13:00:03Z

Say goodbye to viewing PDF files with an external tool. Do it within your WinUI app using the Telerik PDF Viewer component. Get to know it more.

Today almost everyone has a version of Adobe Reader or another program on their computer that can read a PDF file. Some people even have multiple, and most of them warn of an expired trial version.

Well, what about the case in which you are the one responsible for providing your end users the ability to view PDF documents within the app you are developing? Think no more, just open your arms and embrace the first PdfViewer control in the WinUI world—the RadPdfViewer!

In this blog, I will introduce you to the PdfViewer component of Telerik UI for WinUI. And the numerous features for viewing and manipulating PDF files it offers, of course.

Dive In

Officially shipped with UI for WinUI 2.0.0, the PdfViewer has surely not stopped its evolution ever since. A new set of features has recently been introduced with the release of UI for WinUI 2.1.0.

All in all, I believe it is best if we first learn how to reach this beauty:

Prerequisites include an already-set-up WinUI project and, of course, installation of the Telerik UI for WinUI components. Once you have that, don’t forget to add the assembly references to the project. The rest is super easy—a single line of code:

Make sure to point the correct path to your app’s PDF doc, though.

The above code gives you access to the PdfViewer through the xmlns:telerik="using:Telerik.UI.Xaml.Controls" alias. And the DocumentSource, as you might have already guessed, is the one responsible for rendering the PDF file. The property is of type PdfDocumentSource, which allows you to provide a file Stream or Uri to load the PDF document model.

That’s just basics. Let’s dig a little deeper.

Under the Surface

One of the best things about the PDF viewer is the freedom it gives to you and your WinUI apps. What is better than viewing PDF documents right within the app, without the need for an external viewer, right?

But that’s not all. I am a fan of its total ease of use, too. Maybe the PdfViewerToolBar it comes hand in hand with plays a major role in that? All the common interaction options come with it.

All About the Toolbar

The icons of the toolbar buttons are self-explanatory, aren’t they? Just in case, let me list the options:

Opening PDF documents
Saving the previewed document as a new file
Rotating the document
Navigating through the pages with the page up/down buttons, and the textbox, of course
Zooming in and out through the zoom in/out buttons, as well as choosing a predefined zoom level using the combo box next to them
Fitting the document either to the window width, or fitting the whole page to window
Choosing between the interaction modes of the control—pan or text selection

In case you do not need some of the above buttons and the functionality they enable, you can toggle their visibility through the properties listed in the WinUI PdfViewer ToolBar section of the control’s online documentation.

Under the Skin

Is there more than just a toolbar? Yes, there is. You can extend and customize the control with the help of its rich API. Be sure to check out the WinUI Pdf Viewer section in the documentation, as I do not want to flood you with too much information.

Well, I changed my mind a little. I cannot help but mention the support for various fonts (TrueType, Type 1, Type 3 and CID) and documents encrypted with Encryption Algorithm 4 (RC4/AES-128). Oh, and the extensible support for different stream compression filters.

P.S. The RadPdfViewer uses Windows Composition rendering for native performance, and I can assure you that this performance is amazing with large documents.

Sign & Verify

Cool things don’t stop. With the WinUI PdfViewer you can also display, sign and verify documents within your app and make sure that these documents have not been tampered with.

I am talking about digital signatures. In case you are not familiar with them, I will try to summarize—these are equivalent to the handwritten signature but are intended to solve security problems in digital communication. They are unique to each signer and widely used to confirm that the document content originated from the signer and has not been modified in any way.

When a document containing a signature field is loaded in RadPdfViewer, you can apply a signature to it. This is done through the SignSignatureDialog, which gives you the ability to choose a .pfx file representing the certificate and enter the password for it. Clicking the Sign button prompts you to save the signed document to a new file. The newly saved file then opens in RadPdfViewer. Shall we try it together?

To use the SignSignatureDialog you should first register it like this:

Let us verify the signature now.

Whew, we made it. Sign-ificant! ✨

Protection Check

I mentioned earlier that the PDF viewer can open password-protected files. I am curious to check this out, too. Follow me.

Make sure to use stronger passwords, though.

Note that we have added an extra button for opening a protected document in the toolbar. You can check the code of the demo to see how to add your own buttons to the PDF viewer’s toolbar.

And do not wonder where I found these awesome demos—go ahead and get the >Telerik UI for WinUI Examples now.

P.S. In case you need to find something in the documents that you will preview once you do this, just hit Ctrl + F.

Actions Matter

Your feedback is very important since it helps us hear your voice and determine the direction to take with the development of the products. If you’d like something new or different, do not stand still—share your thoughts in the comments below or use the Feedback Portal.

And since we’re speaking about actions, another one is to plug the PdfViewer in your WinUI app and give it a spin—it’s a certain win. Existing customers can access the bits of Telerik UI for WinUI in your Telerik account and for new users use the link below.

Try the Latest Telerik UI for WinUI

What’s New in R2 2022 With Telerik Desktop and Mobile Components

2022-05-11T13:55:40Z

Today, we are excited to announce the availability of R2 2022 release. In this blog post we will cover the highlights of the release for the Telerik desktop and mobile products.

R2 2022 brings a plethora of new components and features for Telerik mobile and desktop products, support for the latest Preview of .NET 7, ARM64 support and an extremely beautiful new Windows 11 theme for the desktop products. The Telerik UI for .NET MAUI suite also continues to grow with new components and desktop support, making it the largest UI component suite for .NET MAUI out there.

Here are a few links to the different sections in this blog to help you navigate directly to the section of interest.

Telerik UI for .NET MAUI

New DateTimePicker Component

One of the new additions to the Telerik UI for .NET MAUI family is the .NET MAUI DateTimePicker control. It provides users with an easy and intuitive way to pick a date and/or time. The component has several features that allow you to set a date range, date and time format, and fully customize the dialog appearance.

Here are some of the key features to look for:

Spinner format: The component allows you to use a standard or custom date format string through its SpinnerFormat property. Depending on what format is set, the picker visualizes spinner controls with the prepopulated values ready to be picked.
Picker mode: You can choose between Popup and DropDown UI for showing the spinner controls with the available date and time values. For desktop, the default picker mode is DropDown, while for mobile it’s Popup.
Templates: The DateTimePicker provides templates for its header and footer as well as exposes templates for its placeholder and display text.
DisplayString format: You can choose what text will be displayed when a date is selected by using the DisplayStringFormat property of the DateTimePicker.
Date ranges: You can also define date ranges by setting minimum and maximum date values and choose a date within that range.
Flexible styling API: The DateTimePicker provides a number of styling capabilities.

For more information on getting started with the Telerik UI for .NET MAUI DateTimePicker control, visit the documentation.

Desktop Support for All Picker Components

With R2 2022, we are introducing desktop support for the powerful picker components—you can now use them to develop apps for Windows and macOS. The full list of updated controls includes .NET MAUI DatePicker, TimePicker, TimeSpanPicker, ListPicker and TemplatedPicker.

Moreover, with this release, all listed components (plus the DateTimePicker) now have a PickerMode property, which lets you choose what interface to use for picking a value. The default picker mode for mobile is Popup and for desktop—DropDown.

Popup – Shows the UI for picking a date inside a popup. It’s the default value for mobile (Android and iOS).

DropDown – Opens the UI for picking a date inside a dropdown. It’s the default value for desktop (Windows, macOS).

Updated NumericInput Component

In line with our commitment to provide the best, most comprehensive .NET MAUI UI library, we work hard to ensure developers can build native applications for Windows, macOS, Android and iOS, taking advantage of the technology’s full power. That’s why one of the main goals of this complete redesign of the NumericInput component was to migrate it from a Xamarin.Forms Renderer to a native .NET MAUI Handler. Beyond that, you can expect mobile-first views on iOS/Android and a desktop-friendly look when running on Windows/MacOS.

New BadgeView Component

The new BadgeView component brings a modern way to notify users or grab their attention to perform a certain activity on your application in a mobile or desktop scenario.

Subtly alerting the users of your .NET MAUI applications for status changes has never been easier! The Telerik UI for .NET MAUI BadgeView control allows you to display notifications or short messages via a set of predefined badges right into your cross-platform application.

Here are some of the key features:

Badge Position: BadgeView allows you to specify the badge position based on its content.
Badge Alignment: You can easily align the badge according to its content.
Badge Animation: You can choose whether to have an animation while displaying the badge. In addition, you can specify the animation duration and animation easing.
Badge Types: You can choose between various predefined badge types. Also, you have the option to customize and style the badge types.
Flexible Styling API and Customization Options: The styling capacities of the BadgeView control allow you to apply BackgroundColor, Border Thickness and Color. Also, we have an exposed API, which you can use to fully customize and style the badge indicator.

For more information on getting started with the Telerik UI for .NET MAUI BadgeView control, visit our documentation.

Updated Entry Component

The Telerik UI for .NET MAUI Entry component has evolved. The text entry control that accepts string inputs is now built against the latest UI guidelines and comes with many enhancements in its API. Here are the most important features of the control:

Password functionality: You can hide the characters that users type for privacy and security reasons.
Keyboard support: You can add a virtual keyboard and specify its type—for example, Numeric.
Non-editable (read-only) state: You can define whether users will be able to edit the Entry or not by setting a single property.
Maximum number of symbols: The Entry component enables you to set a maximum length for its input.
Text selection: You can specify the starting position of the selected text as well as the number of characters of the selected Entry input.
Text prediction: Define whether to have a predictive text while typing in the Entry.
Validation: If the user is entering a value not matching the requirements, the Entry will display an error message, which you can easily customize.
Clear button: Gives you the option to clear all the text entered in the Entry using a single button.
Commands support: Use the Return command to implement additional logic when pressing the keyboard return key.
Various styling options: For applying corner radius, clear button color, placeholder color and more.

For more information on dabbling with the Telerik UI for .NET MAUI Entry control, visit the documentation.

Telerik UI for WinUI

PdfViewer

Announcing the first PdfViewer control in the WinUI world—RadPdfViewer! View PDF documents right within your WinUI application without the need for an external viewer. Allow your users to easily operate with the currently loaded document through the additional PdfViewerToolbar control providing all the common interaction options. Check out the full list with features below:

Pan and Text Selection view modes
Zooming
Smooth scrolling
Rotation of document
Save As – option to save the previewed document to new file
PdfViewerToolbar – predefined Toolbar control providing all the common PdfViewer functionalities
Fonts – support for TrueType, Type 1, Type 3 and CID fonts
Virtualization for ensuring great performance with large documents
Extensible support for different stream compression filters
Support for documents encrypted with Encryption Algorithm 4 (RC4/AES-128)
The API provides different options for extending and customizing the control
Uses Windows Composition rendering for native performance

For more information about the control, make sure to check out the WinUI Pdf Viewer section in our online help documentation.

TabControl

RadTabControl is a flexible navigation component, used to build tabbed interfaces in WinUI applications. Thanks to the related RadTabItem control, you can organize your controls into different content pages, thus improving the overall user experience (UX) of your applications. Here are the top feature the control provides:

Built-in pin and close functionality buttons in the tab headers
Drag reorder for tabs is available out of the box
Multi-line tabs support
Flexible tab headers – tab headers are easy to customize by incorporating content or Data Templates
Selection – manipulate the selected tab and define the control behavior on tab close
Data Binding – the control can be data bound to a wide variety of data sources
Overflow – when the available space is not enough, the tabs will overflow in an overflow area
Theming – style and customize the control utilizing the rich styling API
Customization – built in options for defining tabs position, alignment, orientation, size, style and more

For more details, check out the WinUI TabControl section in our help documentation.

HeatMap

RadHeatMap is a control that displays numeric data in a matrix-like manner using two axes. Each value is represented by a colored rectangle, which makes it quite easy for the end user to quickly perceive and compare all values.

Here is a list with the main features of the control:

Visualization Mechanisms – Categorical and Horizontal/Vertical
Colorizers – different options colorize the values
UI Selection – built-in Single and Multiple selection
Tooltips – specify a Tooltip template and display the details of the item
Labels – show custom labels in the cells
Header Customization Options – easily change their appearance
Customization Options – change the appearance of the control as well as its elements

Make sure to play around with the control in our WinUI examples app and to check the RadHeatMap section in our help documentation.

ChartView: Minor Ticks and Stripes (Breaking Change)

The new minor ticks support will allow you to utilize a more punctual view of the ticks in the axis. With it, you can define the number of minor ticks to be displayed between major ticks. They are heavily customizable with the available APIs to define the number of minor ticks between major ones, the tick length, offset from the major tick, the tick template and style.

With the support for minor ticks, another useful feature is the support for stripes. Stripes are the visual representation of the minor ticks in the chart area and can be used to display where the minor ticks are, for the user to easily spot the value of a certain tick and compare it to a data point on the chart. Stripes support defining the stripe visibility, style, dash array and more.

Important: With the minor ticks feature we renamed some of the already existing properties listed below:

PolarChartGrid
- GridLineVisibility -> MajorGridLinesVisibility
- StripesVisibility -> MajorStripesVisibility
- PolarLineStyle -> MajorPolarLinesStyle
- RadialLineStyle -> MajorRadialLinesStyle
CartesianChartGrid
- StripLinesVisibility -> MajorStripLinesVisibility

For more details, check out the Minor Ticks and Stripes article from our Chart documentation.

Latest Windows App SDK Support (1.0.3)

As usual we are up to date providing support for latest Windows App SDK version 1.0.3.

Document Processing

For a list of the new features shipped in the Telerik Document Processing Libraries shipped with Telerik UI for WinUI, see below.

Check Out the Detailed Release Notes

We have a lot more! To get an overview of all the latest features and improvements we’ve made, check out the release notes for the products: Telerik UI for WinUI (Release Notes).

Telerik UI for WPF

VirtualKeyboard

Announcing the brand-new WPF VirtualKeyboard component. RadVirtualKeyboard is basically a screen keyboard that mimics the familiar physical device. Users can interact with the Virtual Keyboard via the mouse or a touch device and, for richer experience, the default click or any custom sound can be enabled. The component can be also placed directly in XAML, in a convenient place in your application or it can be shown above the app through the dedicated RadVirtualKeyboardWindow that will allow you to use it for all other applications.

Here is list with major features the control provides:

Layouts – There are three predefined key layouts and an option load completely custom layout from XML file.
Display options – The keyboard can be shown inline or in a dedicated window that can be moved.
Customization – The visualization of each key can easily be changed.
System synchronization – Tracks system language changes and updates the keys automatically.
Culture support – The component supports assigning a specific culture that will be applied to the letter keys.
Native key input – Each button click sends a native key down action that is passed to the currently focused element.

I hope this control will be useful in various types of applications. For more information, check out our online VirtualKeyboard help documentation.

Windows 11 Theme

The newest and most modern Telerik UI for WPF theme is here—welcome the Windows 11 theme! It is inspired by the Windows 11 OS and brings nice smooth round shapes in two color variations—Light and Dark. Enjoy the out-of-the-box native look and feel of RadWindow when the app is running on Windows 11 with the famous Mica backdrop material effect! A couple other cool things about the theme are the System color variation that automatically transforms the theme depending on the systems settings and the option to use the system accent color as accent color of theme.

You can see below how some of most popular controls look wearing the new theme:

They look good, don’t they?

As with our other recent WPF themes, you can easily customize the theme colors to suit your taste with the Color Theme Generator for WPF! For more details about all the features of the theme, please check out this help article.

The theme comes with brand-new Telerik font with glyphs—for more details, check out the Font Glyph section from our online help docs.

Latest .NET 7 Preview and ARM64 Support

As always, we are up to date with the latest technology trends, and we are happy to announce that Telerik UI for WPF provides .NET 7 Preview 3 and ARM64 support. The .NET 7 Preview binaries can be found in a separate zip archive in your Telerik account—download it and give it a try!

As for the ARM64 support, this means that your .NET 6 app built with Telerik UI for WPF will run flawlessly on a device like Surface Pro X (with ARM64 processor)—test it if you have such a device and let us know if you have any feedback.

VirtualGrid: Support for UI Elements in the Cells (Cell Templates)

RadVirtualGrid becomes even more powerful with this feature. Now it is possible to apply custom cell template on each cell and show whatever content you want—UI elements, images, other controls—it is up to you. What you need to do is to hook to the CellTemplateNeeded and provide the desired DataTemplate depending on the cell value.

Make sure to check out the Custom Cell Content article for more details.

ChartView: Minor Ticks and Stripes

For more about those features, see the Minor Tick and Stripes article from the WPF ChartView help documentation.

GridView: Zooming Support & Filtering TextBox for Distinct Values

This release we are adding two highly desired features GridView features:

Zooming – now the control can be zoomed programmatically or with the Ctrl + MouseWheel combination. To enable zooming with the mouse, you would need to set the EnableMouseWheelScaling property of the control to true. For more details, check out the Zooming article from the WPF GridView documentation.
Filtering the Distinct Value – you can now easily display filtering TextBox inside of the Filtering Control. Users will no longer have to scroll down the distinct filtering values and can quickly type in a desired value to find it.

DesktopAlert: Show on the Current Display

Until this release, it was only possible to display the DesktopAlert on the main monitor even if your app was on the secondary monitor. With this new feature, you will be able to show the alert depending on the location of your application window (or any window). You need to simply attach the DesktopAlertManager to the desired Window:

var manager = new RadDesktopAlertManager();
manager.Attach(App.Current.MainWindow);

And that’s it—the alerts will be automatically shown on the monitor where the Window is currently located. For more details, check out the Show on Current Screen help article.

Spreadsheet: Conditional Formatting

Based on your feedback, we are happy to introduce a conditional formatting functionality in the Spreadsheet control for WPF. With it, your end users can easily format the entire sheet or section based on either some of the readily available predefined conditions or by utilizing formulas. To learn more visit the Conditional Formatting documentation article.

Spreadsheet: Support for Threaded Comments

After introducing the Notes functionality in the previous release, we have now upgraded the components to enable you to also work with comments and replies. You can check our help topics for more information WPF Spreadsheet Comments.

Spreadsheet: Support for References to Whole Columns and Rows

Now you can use references to whole rows and columns instead of specific cell ranges only. You can use this functionality to include all the values from a row/column to a formula, for example.

Spreadsheet: CONCAT Function

Although the components support 200+ built-in functions, we keep adding more to ensure everything you might need is ready to use. The full list of supported functions is available in the Functions article.

Document Processing

For a list of the new features shipped in the Telerik Document Processing Libraries shipped with Telerik UI for WPF, see below.

Other Features

ChartView: Added ability to control the tension of the spline ( link)
ChartView3D: Added SeriesProvider for dynamic creation of series ( link)
ContextMenu: Modifier keys can be show without holding Alt when opening the menu via mouse's right button ( link)
Diagram: Fit-to-page support plus additional setting of the print preview dialog ( link)
Pivot: Named sets are placed in a correctly named folder, read from a cube’s metadata

Check Out the Detailed Release Notes

We have a lot more! To get an overview of all the latest features and improvements we’ve made, check out the release notes for the products below:

Telerik UI for Xamarin

The second official release for the year of Telerik UI for Xamarin, namely R2 2022, has just arrived giving you much requested ProgressBar control, as well as DataGrid improvements and a demo for sharing/saving pdf files.

ProgressBar

The ProgressBar control allows you to display to your users the progress of a long-running operation, such as downloading a file, requesting information, etc. The ProgressBar sets a clear expectation of the load time, so it’s quite useful in a number of scenarios when the action takes more than a few seconds. The ProgressBar for Xamarin comes packed with a variety of useful features like indeterminate state, segments support, as well as being fully customizable.

Let’s take a closer look at the features the new ProgressBar for Xamarin provides!

Value, Value Range & Progress

The Value property defines the current progress status of the ProgressBar. There are options for specifying the value range with the Minimum and Maximum properties.

The Progress property, on the other hand, is used to report the current progress status. Progress is updated internally after Value is updated and progress animation is complete.

Indeterminate Mode

ProgressBar is used to visually indicate the progress of a task. Still, there are cases when the progress is unknown—in those scenarios use the indeterminate mode of the control:

Segments Support

Divide ProgressBar into segments in cases the task has predefined number of steps—this is as easy as just applying SegmentCount property:

Label Customizations Options

In addition to the progress indicator, the ProgressBar control also shows a label to provide more information on the current progress. As the design requirements may vary from case to case, there are various customization options available—you can set the label horizontal alignment, apply string format, as well as use different display modes—display the progress as Value, as percent from the range from minimum to maximum, or use custom text.

Here are some examples of label customization options:

Styling Options

If you want to customize the ProgressBar color scheme so it matches the design of your app, we’ve handled that as well. ProgressBar provides flexible styling API for customizing the progress fill, track fill, indeterminate fill, label text color, font size and more.

For a full list of the styling properties, visit the ProgressBar: Styling documentation topic.

DataGrid Row Height

DataGrid provides full control over the way its cells are rendered through various Column types—TextColumn, NumericalColumn, BooleanColumn and TemplateColumn, to name a few. Still, there was one missing bit—until now there wasn’t a direct way to explicitly define the height of the grid rows. Now with R2 2022 release, Telerik DataGrid for Xamarin exposes the RowHeight property, which gives you a quick and easy way to control the height of each row. For detailed information on how to use the new property, refer to DataGrid: Row Height documentation topic.

Document Processing

For a list of the new features shipped in the Telerik Document Processing Libraries shipped with Telerik UI for Xamarin, see below.

Demo for Sharing/Saving PDF Documents

We have received many requests to provide options for sharing and saving PDF documents from the PdfViewer’s Toolbar. Then we decided to create a demo that includes these two options. You can find the running demo in our Telerik Xamarin Sample application.

For Pdf Sharing we used the Xamarin.Essentials Share class.

private async Task ShareAsync()
{
    Assembly assembly = typeof(SaveSharePdfView).Assembly;
    string fileName = assembly.GetManifestResourceNames().FirstOrDefault(n => n.Contains("pdfviewer-firstlook.pdf"));
    Stream stream = assembly.GetManifestResourceStream(fileName);
    var cacheFile = Path.Combine(FileSystem.CacheDirectory, "pdfviewer-firstlook.pdf");
    using (var file = new FileStream(cacheFile, FileMode.Create, FileAccess.Write))
    {
        stream.CopyTo(file);
    }

    var fileShareService = DependencyService.Get();
    await fileShareService.ShareFileAsync(cacheFile);
}

For Pdf Saving the document visualized in the viewer is saved on the local application data.

private async Task SaveAsync()
{
    var fileName = "pdf-telerik.pdf";
    var localFolder = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
    var filePath = Path.Combine(localFolder, fileName);

    if (this.Document == null)
    {
        return;
    }

    using (Stream output = File.OpenWrite(filePath))
    {
        var provider = new PdfFormatProvider();
        provider.Export(this.Document, output);
    }
    await Application.Current.MainPage.DisplayAlert("Saved on this device as pdf-telerik.pdf.", "Location: " + filePath, "OK");
}

New Features in Telerik Document Processing Library

PdfProcessing: Choose whether the font files to be embedded when exporting PDF documents.

RadPdfPdocessing library provides easy to use API which allows you to choose whether to include the font files while exporting the pdf document.

❗ Removing the fonts from the PDF document makes it dependent on the operating system to provide the needed fonts. If they are not installed on the system, the document will not be successfully opened.

SpreadProcessing: Comments support

Easily insert a comment related to a specific document position. In addition, you can add replies to each comment. A sample runnable demo can be found in Telerik Xamarin Sample application under the SpreadProcessing control section.

Telerik UI for WinForms

Below we will look into what the R2 2022 release of Telerik UI for WinForms brings.

New Component: Office Navigator Bar

With the new Office Navigation Bar control, developers can create intuitive navigation in WinForms applications, similar to the one Microsoft Outlook provides. The control features a list of items represented by text and/or images that the user can select. In addition, there is an overflow functionality for the items that cannot fit in the available space.

My favorite feature of this component is the peek functionality—a popup that is shown above the items on mouse hover. This popup can contain any Windows Forms Control in it and is convenient either for allowing the user to perform a quick action or to display some additional information.

Feature highlights:

View Modes – Two view modes are available: Compact to display just image or text in the item, and Full where both image and text are displayed.
Overflow – Items that cannot fit in the control will overflow into a menu for the user to access them.
Peek Window – A window displayed when the user hovers the item and where any control can be added.
Options dialog – A built-in dialog with options for configuring Visible items, Display Style and Item order, which the user can access via the overflow menu.
Design-time support – A convenient designer is available, allowing to configure the main options of the component from its Smart Tag.
Localization provider – A convenient localization provider allowing translating the control strings into a language of your choice.

New Component: Calculator

We have heard from our users that some LOB applications can take advantage of a calculator component, embedded in the WinForms app. Meet RadCalculator—an easy-to-use component that can be added to Windows Forms applications and enable users to make calculations right in the app, without the need to switch context.

Feature highlights:

All basic calculations like add, subtract, multiply and divide come out of the box
More complex calculations are also available – reciprocal, sq root, negate, percentage
Memory functions – all the memory calculations that you may expect are readily available: M+, M-, MS, MR, MC
Custom calculations – utilize the flexible API to create your own calculation that the control will execute
Easy-to-customize UI – the entire UI is highly customizable; you can access every element of the control and amend its look and feel, or add your own elements
Touch and keyboard support is provided out of the box

Compatibility With Preview 3 of .NET 7

For the enthusiasts who always want to play with the latest .NET version, together with the official bits of R2 2022, we are also shipping bits that target Preview 3 of .NET 7 so you can continue to use your favorite Telerik UI for WinForms controls in your development. Once you install R2 2022, look into the installation folder for assemblies build for .NET 7.

ARM64 Support

With .NET 6, Microsoft has shipped native support for ARM64 on machines that run Windows on ARM devices like Surface Pro X, Samsung Galaxy Book and more. We are happy to confirm that all Telerik UI for WinForms controls are compatible with ARM64 and can be utilized for applications targeting it.

VisualStudio 2022 Theme: Color Blending

In the previous release, we shipped the awesome Visual Studio 2022 theme, and this release we are happy to share that we have also enabled the color blending functionality for it. With color blending, you can easily blend every color used in the theme with another color of your choice, which allows you to quickly change the color scheme used in a particular theme.

More Interactive .NET Core Designer Now With Support for Item Glyphs and Inline Editing

This release marks a major milestone for Telerik UI for WinForms in the adoption of the new Windows Forms designer in Visual Studio. We are excited to share that we are the first and only vendor on the market who now has full feature parity between the old and the new WinForms designer in Visual Studio, and users of Telerik UI for WinForms can now enjoy the full designer experience when crafting their applications.

Improved High DPI Support

This release brings yet another set of improvements in the Telerik UI for WinForms support for high DPI WinForms applications, including dynamically scaling controls added at runtime, scaling improvements to support all combinations of .NET versions and DPI awareness modes, precise scaling in all types of Forms and UserControls, and many other improvements.

Revamped BarCode Component With Support for Reading Barcodes

With this release, we are shipping a fully revamped BarCode component—RadBarCodeView—that brings many improvements to our barcodes story, including a BarCode reader capability, which can be used to decode barcodes from Bitmap images.

Feature highlights:

Support for one-dimensional barcodes like EAN13, EAN8, UPC-A, UPC-E and Code39 symbologies
Support for two-dimensional barcodes like QR code, PDF417, and Data Matrix
BarCodeReader for decoding one dimensional barcodes like Code 11, Code 128, Code 25 Interleaved, Code 25 Standard, Code 39, Code 39 Extended, Code 93, Code 93 Extended, Codabar, Code MSI, EAN 13, GSI 128, EAN 8, Postnet, Planet, Intelligent Mail, UPC A, UPC E, UPC Supplement 2, UPC Supplement 5

Document Processing

For a list of the new features shipped in the Telerik Document Processing Libraries shipped with Telerik UI for WinForms, see below.

Telerik Document Processing Libraries

SpreadProcessing: Support for Threaded Comments

After introducing the Notes functionality in the previous release, we have now upgraded the components to enable you also work with comments and replies. You can check our help topic for the available API.

SpreadProcessing: Support for References to Whole Columns and Rows

Now you can use references to whole rows and columns instead to specific cell ranges only. You can use this functionality to include all the values from a row/column to a formula, for example. All types of references and examples of how you can use them are available in the Reference Ranges topic.

SpreadProcessing: CONCAT Function

WordsProcessing: Support for Continuous Section Break When Exporting to PDF

This type of section break was exported as a page break in previous versions of WordsProcessing. It is now properly respected, and the layout of the document is preserved.

WordsProcessing: Support for Alternate Text of Images

The alt attribute of the img HTML element is preserved even when its value is an empty string. The functionality is also supported for the image shapes defined in a DOCX document.

PdfProcessing: Support for Type 3 Fonts

The Type 3 fonts are a feature specific to the PDF standard. The Type 3 fonts consist of glyphs defined with PDF graphic operators. Usually, the entire font is embedded in the PDF document, which allows you to view it on devices without accessing fonts from the operating system. With R2 2022, PdfProcessing provides you with full support for this type of fonts.

PdfProcessing: Support for Setting Different Permissions When Creating Encrypted Documents

These settings enable you to specify whether the user can print the document, copy or modify its content. For more details, check the PdfFormatProvider|Settings topic.

PdfProcessing: Exposed Settings Allow You To Control Font Embedding

The PDF standard requires all fonts except the standard ones to be embedded inside the document to ensure it will always look the same way no matter the device or application used to open it. However, this inevitably leads to increasing the file size. With PdfProcessing, you are now allowed to skip the embedding if the file size is crucial for the scenario. For more information on how to use this functionality, check the PdfFormatProvider|Settings topic.

Got Feedback?

As always, we highly appreciate user feedback, and we would like to invite you to continue sending it to our feedback portals. Only with your feedback we can be sure that we are building the things that you benefit your application development the most!

Download the Latest Bits

For existing users to download the latest bits, visit the Download section of Your Telerik Account or get the Telerik Control Panel and it will take care of that for you.

For all new users who want to try the products, visit the following pages:

Live Webinar and Twitch Session—May 16 & 17

Join us for the live R2 2022 release webinar on Tuesday, May 17 at 11 a.m. ET as our Developer Advocates Ed Charbeneau and Sam Basu present in detail the major updates across our .NET UI libraries.

Save your Seat

In addition, we will be hosting a live Twitch demo session on Monday, May 16, 10:00 a.m. ET, where our Developer Advocates dive into their favorite new features in an interactive live streaming session.

Let It All Bloom With the Map Smooth Zoom (WPF and WinUI)

2022-03-03T13:19:05Z

Have you checked the latest releases of Telerik UI for WPF (R1 2022) and Telerik UI for WinUI (1.0)? I have and here is what I notice—the Map control of both suites now supports smooth zooming! If you are as eager as me to explore it, get your glasses ( or ) and read on.

The Meaning of Smoothness

Let us assume that we are developing an interactive cartographic application. The user is presented a map of, say, the U.S., and can zoom in on regions, states and cities by picking items from a list or clicking on areas on the screen. What if a user double-clicks an item and the map suddenly reaches that zoom level without a smooth transition? Not cool, and, sadly, this is still all too common nowadays.

Information visualization strongly needs smooth transitions. Abstract data is typically mapped to 2D graphic representations (e.g., scatterplots, graph diagrams, treemaps). Large data sets lead to large images with much detail. Interaction with these representations is vital to achieve insight.

What should be properly addressed is the importance of being able to view things at different levels of scale, or for short multiscale viewing. And being able to perform such operations the right way.

Decision ‘Precision’

As we learned in the previous section, many tasks on a map control require smoothness for a better user experience. An example of such an operation is zooming.

A particularly important part of zooming is the zoom level. It determines how much of the world is visible on a map. At low zoom levels, a small set of map tiles covers a large geographical area. At higher zoom levels, a larger number of tiles cover a smaller geographical area.

Until now, the RadMap control for both WPF and WinUI provided zooming by levels that are integer values. This means that you always needed to zoom from level 5 to 6, for example. Not the decision for precision that the title of this section suggested, huh?

Relax! The latest releases of Telerik UI for WPF and Telerik UI for WinUI got that covered. Precise zooming options are delivered, and I am ready to walk you through them.

Likeness and Unlikeness

In this section, I will show you what both maps have in common and where the difference is as it comes to precision of zooming.

Starting with the most important—both map components allow for a more precise zooming option through their Zoom property. As you may guess, it is of type double, enabling you to easily zoom in to, say, 5.5 or any other value until you reach the next integer zoom level. A small, but significant difference here—this property is an additional one for WPF. For WinUI, there was a ZoomLevel property which has been removed with the introduction of the new Zoom property.

Both controls enable the end user to zoom in and out of the context of the map via the mouse wheel or through the zoom option of the commands bar panel. Another common addition is the option to control the zoom step of the mouse-wheel zooming and of the slider in the UI—the ZoomStep property. By default, the control will zoom in and out by one level. The key to smoothness is a smaller value of the ZoomStep property. This will affect both the zooming initiated by the mouse wheel and the buttons of the zoom slider.

I promised to talk about what is similar and what is not regarding zooming precision. Stopping here, as I am afraid that I can get carried away. But feel more than welcome to learn all about the zoom related features in the Zooming articles of the RadMap’s documentation for WPF and WinUI.

So much talking and not a single map in this blog? Let me fix that.

Zoom Into the World With WPF

Do you fancy visiting Las Vegas, San Diego and Phoenix (again?), or there is no need for me to ask? Let us first try that with our WPF RadMap control.

A few things for the above GIF settings. We started with the following:

A 6.0 zoom
The default 1.0 zoom step
A VisualizationLayer containing the three pinpoints representing the cities we want to visit

I increased the zoom to 7.0 and sadly two of the cities got lost from the viewport of my map. Then I tuned in the zoom step to be smaller—0.1—and I started zooming out to find the perfect zoom for my map and the points of interest on it.

The rest was just for the enjoyment of my eyes. To fully taste the smoothness of the zooming.

Since I already know the best zoom settings to my taste for the POIs that I chose, I am ready to share it with you:

<telerik:RadMap x:Name="radMap" Zoom="6.5" ZoomStep="0.1" Center="34.68918810838,-114.832387568751"/>

Now I want to give the world a whirl with the WinUI RadMap, too, don’t you?

Zoom Into the World With WinUI

I will simply copy-paste the above setup from the WPF world into a fresh WinUI app. Of course, I will need some small adjustments to get it running. For example, updating the namespaces with the ones for WinUI (Telerik.UI.Xaml.Controls.DataVisualization and Telerik.UI.Xaml.Controls.DataVisualization.Map will be needed). And (very important ⚠️), adding the Generic.xaml to the App’s MergedDictionaries:

<Application.Resources>

<ResourceDictionary>

<ResourceDictionary.MergedDictionaries>

<XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls" />

<ResourceDictionary Source="ms-appx:///Telerik.WinUI.Controls/Themes/Generic.xaml"/>

ResourceDictionary.MergedDictionaries>


    ResourceDictionary>

Application.Resources>


I am ready, so let us hit F5 and check the result together.  

Pretty, pretty, pretty. 
If you want to dig deeper, you can try the GetBestView() method of the map’s visualization layer to find the LocationRectangle that is the best for your map’s viewport. Once you get that, you call the SetView() method of the map with the useFractionZoom parameter set to true. This way, you will receive the most optimal (according to the methods and their algorithms) view zoomed to the most precise level for your viewport. It is worth a try, but I will leave it all to you this time—I do not want to spoil you.
It is now time for a wrap.
A Minute for Feedback 
That is how long it mostly takes. So, if you have a minute, feel free to drop us a comment sharing your thoughts below. Or visit our Feedback Portals about UI for WPF and UI for WinUI and let us know if you have any suggestions for more awesome features like the map’s smooth zooming or (why not) controls that will improve your work. Let us shape the feature of both products together.  
Also, be sure to try out the latest:
UI for WPF UI for WinUI



What’s New in WinUI 1.0
2022-01-19T16:41:06Z
Announcing Telerik UI for WinUI 1.0—the latest WinUI release is live today.
In this release you will find Windows App SDK 1.0 support with the latest windows styles, new Button controls, plus new features for DataGrid, Map, BusyIndicator and Document Processing libraries.
Windows App SDK 1.0 Support and Updated Styles

The latest stable version of Windows App SDK 1.0 was announced by Microsoft back in November, and we immediately released support for it in Telerik UI for WinUI v. 0.7. After that moment, were focused on updating the visual appearance of our components and restyled them in the same manner as seen in Windows App SDK 1.0, using the latest Windows styles. You can install our examples application from the Telerik UI for WinUI Examples web page and check out the latest look and feel!  
Buttons

Surprise!!  Introducing RadButtons for WinUI—this is set of buttons that we will be extending in the future. Every button provides the standard set features for its type plus additional customization options and functionalities (like CommandTarget support). This is the current list of RadButtons:

    RadButton
    RadDropDownButton
    RadSplitButton
    RadToggleButton
    RadRadioButton

Hope they will be useful. For more details, check out the Buttons section in our help documentation.
 
Map: Smooth Zooming (Breaking Change)

RadMap now supports smooth zooming—in the past it was possible to zoom only by integer values. Now we are introducing new Zoom property of type double that will allow to you zoom more precisely. 

Important Breaking Change: The ZoomLevel property has been removed with introduction of the new Zoom property.

We have also added the option to modify the zoom step of mouse-wheel zooming and of the slider in the UI—check out the ZoomStep property. For more details, check out the Zooming article in the RadMap documentation. 
DataGrid: Group Panel Position

Our DataGrid now provides another option for the group panel position—it can be placed on the top inline. This new setting adds look and feel similar to the Telerik WPF GridView and provides a more convenient way to operate with grouping settings of a control in a desktop environment.

Important Change: This is now the default setting for the group panel position in the desktop version of the controls.

For more details, you can check the Grouping section from the DataGrid documentation.
MaskedInput: Separate Mask Controls (Breaking Change)
A couple of releases ago, we released MaskedInput control (if you missed it, check this great blog post about the component). With this release, we are making an important breaking change, splitting the control into separate mask controls. Here is the list of the new masked input controls:

    RadMaskedTextInput
    RadMaskedDateTimeInput
    RadMaskedTimeSpanInput
    RadMaskedNumericInput
    RadMaskedIPInput
    RadMaskedEmailInput
    RadMaskedRegexInput

For your convenience, we have prepared a Migration from RadMaskedInput article for more details on the exact changes. Please contact us if you have any difficulties when migrating to the new control—we will be glad to help!
SpreadProcessing: Conditional Formatting
This feature gives you the ability to format the cells depending on their value. There are multiple conditional formatting rules that are supported and can be used for this. You can apply various formatting options like changing fill and font and even create more complex rules with data bars, color scales and icon sets. You can see some examples in the screenshot below.

Spreadsheet and SpreadProcessing: Notes Support
Notes are used for making notes or annotations about the data in a specific cell. You can easily work with Notes via the UI. You can add, remove, edit, resize, show or hide the Notes. This can be done from the button in the review tab or from the context menu.

You can work with Notes in the code behind as well. Detailed information is available here: Notes.
WordsProcessing: Nested Mail Merge
This functionality allows you to perform mail merge with complex business objects. For example, your business object can contain a list of other objects and this functionality allows you to use the underlying objects when performing mail merge. In this case, a special field syntax with custom field modifiers (for example: GroupStart/GroupEnd) is used. More information about this feature is available here: Mail Merge.

Other Features

    BusyIndicator: Added OverlayBackground property
    DataGrid: DataTable support (link)
    WordsProcessing: Support for Table.Alignment when exporting to PDF
    WordsProcessing: Add support for height of a table row when exporting to PDF
    WordsProcessing: Export VerticalAlignment property of the table cells to PDF
    WordsProcessing – DocxFormatProvider: Add support for hyperlinks on images

Check Out the Detailed Release Notes
We have a lot more! To get an overview of all the latest features and improvements we’ve made, check out the release notes:
Telerik UI for WinUI (Release Notes) 
Sign Up for the Webinar
To see the new release in action, please join us on the Telerik R1 2022 webinar, on Wednesday, February 2, 2022, from 11:00 am ET – 1 pm ET.
Save My Seat
Join Us on Twitch
Join the live demo sessions on Twitch to see the newly released components and features in action and get ideas on how to use them in your projects. Chat with the team and get your questions answered on the spot! The new WPF release will be covered on Monday, January 24 at 10:00 am ET.
Share Your Feedback

    Get in touch by email – drop us a line, for anything related to product or just to say hi, at TelerikWinUI@progress.com
    Feedback Portal – share any feature request (or bug reports) that you might have
    Telerik Forums – if you need any technical assistance with product let us know and we will help

Get the Bits
Don’t wait—try out the latest:
UI for WinUI
In case you missed it, here are some of the updates from our previous release.


Win With the WinUI Report Viewer for Desktop in Telerik Reporting
2021-12-02T10:10:48Z
The Progress Telerik Reporting family has grown since R3 2021—a new WinUI Report Viewer that can be embedded in WinUI3 desktop applications is now available.
I am sure that you have heard about the Telerik day-zero support for WinUI. This is a long story written by our great developers that started more than a year ago. The first family member was the DataGrid for WinUI component. After it, bit by bit, adding a component after component, the Telerik UI for WinUI family has grown together with the Microsoft WinUI Library. Get to know it by downloading the Telerik WinUI demos.
Having a stable and extensive set of Telerik UI for WinUI controls for UWP and Desktop, what is the next logical step? If you thought about a WinUI Report Viewer, you are right! Delivering a Report Viewer for WinUI seemed an easy task, having in mind all the various Telerik Report Viewers we have already. The list of supported platforms is broad—ASP.NET Core, Blazor, Angular, WPF, Winforms, etc. And here is a little secret from the kitchen—they all share the same engine below the surface.
Wanna know the story of delivering a WinUI Report Viewer? Sure, let’s start. But, oh, two little things you should know first—it was introduced with the R3 2021 release. And tooltips over a report’s content were freshly added with the R3 2021’s Service Pack.
Introduction to WinUI
If this is the first time you are hearing about WinUI or you get confused about its versions, here is a brief intro.
The Windows UI Library is a native UX framework for both Windows desktop and UWP applications. It is based on the Fluent Design System. There are two generations of WinUI under active development—WinUI 2 and WinUI 3. While WinUI 2.x is a control library on top of UWP shipped as a standalone NuGet package, WinUI 3.0 is an entirely new framework that aims to replace the UI and application framework of UWP. WinUI 3.0 is shipped with the Windows App SDK (formerly known as Project Reunion).
Telerik WinUI products aim to target the latest stable version of Windows App SDK.
Telerik Report Viewer for WinUI—The Beginning
It all started with the UI.
The designers followed the outstanding UX experience that we deliver with our other report viewers. First, we created the “skeleton” with the following parts—navigation, document map, report area, parameters area and zooming bar.
Part 1: Navigation 
What is a report viewer without a navigation bar?!
Having such, you can navigate through the pages of the report or the history of the visited reports. You can also customize the page settings, print or export the report, and toggle whether the document map and the parameters area are visible.
For the needs of our report viewer, we used the MS CommandBar with custom content for the AppBarButtons and AppBarToggleButtons to be left-aligned. Also, a new set of path icons was provided by the designers, as some of the needed icons were missing in the predefined WinUI symbol icons set and in the Segoe MDL2 Assets icons.

Part 2: Report Area 
The MS TreeView has an attractive design fitted very well for the document map, whereas the parameters area is a custom control—ReportParametersControl—which changes its template depending on the type of the parameter.
The report area has two views—an interactive template and a print preview template. Switching between the logical and the physical page rendering happens by toggling the print preview button in the command bar.


Below the report, there is a zoom which together with the drill-down and the drill-through functionalities makes the report interactive. The zooming feature was developed with the Telerik LayoutTransformControl and the Telerik RangeSlider, which both could be of great help to a developer.


A small, yet crucial Telerik component was used to lay out all these parts of the report area—the GridSplitter.
Part 3: Finishing Touches
No look seems finished without a little spark.
In the scope of the report viewer’s UX, these were the overlays with informative messages and tooltips over the buttons and inside the reports.
I think here is the part where I tell you that the report viewer supports all six built-in themes – Light, Dark and four High Contrast themes (High Contrast #1, High Contrast #2, High Contrast Light and High Contrast Black).
What Is in the Back 
As mentioned earlier, our Report Viewer is built with both Microsoft and Telerik UI for WinUI components.
The binaries that come with the viewer are:

    one for the functional part (Telerik.ReportViewer.WinUI.dll)
    one for the theming (Telerik.ReportViewer.WinUI.Themes.dll)

The functional part depends on the Reporting engine for rendering the reports. Reports are rendered as standard XAML controls through the Telerik Reporting XAML rendering mechanism, adjusted for the specifics of WinUI.
The WinUI Report Viewer can utilize the report generation engine in several ways:


    as an embedded report engine (in the WinUI application itself) 
    by hosting it remotely utilizing the REST reports service 
     by using the Report Server—a server-based platform that provides storage for reports and enhances their management 


A side note is that the WinUI framework is in active development, and we will continue to add features along with the framework advancement.

What To Expect Next? 
Depending on the demand of our customers, we will cover all functionalities that we already have for the other platforms. A search engine with results highlighting and tooltips client-side events are some of the features that will come next.
Theme It as You Need It
The Telerik Report Viewer for WinUI benefits from the UserThemeResources markup extension provided by Telerik. Its aim is to allow the developers to easily override the resources used in the default themes.
It exposes three static properties—DarkResourcePath, LightResourcePath and HighContrastResourcePath. All refer to the URI path to the resource dictionary containing the theme resource definitions for the respective theme. If no value is set for either, the default Dark theme will be used. Eager to try it? Let’s do it together.
Step 1: Open the Demo Solution
Since R3 2021 SP1 we ship a dedicated solution containing two WinUI projects—a project containing the demo code and a separate Windows Application Packaging Project that is configured to build the app into an MSIX package.

It can be found under the following path:
C:\Program Files (x86)\Progress\Telerik Reporting R3 2021\Examples\CSharp
Make sure to set the package project as a startup one.
Step 2: Add Custom Resource Dictionaries for Each Theme

We will mimic the three Office2019 palettes from the Telerik UI for WPF suite—Light, Dark and High Contrast. How? By adding custom values of the following brushes in each of the resource dictionaries.
CustomResourcesDark.xaml:

<ResourceDictionary
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <SolidColorBrush x:Key="TelerikReportViewer_Background" Color="#FF0F0F0F"/>
    <SolidColorBrush x:Key="TelerikReportViewer_BorderBrush" Color="#FF606060"/>
    <SolidColorBrush x:Key="TelerikReportViewer_CommandBarBackground" Color="#FF3C3C3C" />
ResourceDictionary>


CustomResourcesLight.xaml:

<ResourceDictionary
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <SolidColorBrush x:Key="TelerikReportViewer_Background" Color="#FFDFDFDF"/>
    <SolidColorBrush x:Key="TelerikReportViewer_BorderBrush" Color="#FFACACAC"/>
    <SolidColorBrush x:Key="TelerikReportViewer_CommandBarBackground" Color="#FFF1F1F1" />
ResourceDictionary>


CustomResourcesHighContrast.xaml:

<ResourceDictionary
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
     <SolidColorBrush x:Key="TelerikReportViewer_Background" Color="#FF000000"/>
     <SolidColorBrush x:Key="TelerikReportViewer_BorderBrush" Color="#FFFFFFFF"/>
     <SolidColorBrush x:Key="TelerikReportViewer_CommandBarBackground" Color="#FF000000" />
ResourceDictionary>


Step 3: Plug the UserThemeResources Resource
Add the UserThemeResources definition in the application resources and customize the demo’s background: 

<ResourceDictionary>
    <telerik:UserThemeResources x:Key="themeResourceInitializer"
                       DarkResourcesPath="ms-appx:///CustomResourcesDark.xaml"
                       LightResourcesPath="ms-appx:///CustomResourcesLight.xaml"
                       HighContrastResourcesPath="ms-appx:///CustomResourcesHighContrast.xaml" />
    <ResourceDictionary.ThemeDictionaries>
        
        <ResourceDictionary x:Key="Default">
            <SolidColorBrush x:Key="DemoBackgroundBrush" Color="#FF3C3C3C" />
        ResourceDictionary>

 
        
        <ResourceDictionary x:Key="Light">
            <SolidColorBrush x:Key="DemoBackgroundBrush" Color="#FFF1F1F1" />
        ResourceDictionary>

 
        
        <ResourceDictionary x:Key="HighContrast">
            <SolidColorBrush x:Key="DemoBackgroundBrush" Color="#FF000000" />
        ResourceDictionary>

    ResourceDictionary.ThemeDictionaries>

 
    <ResourceDictionary.MergedDictionaries>
        <XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls" />
 
        
        <ResourceDictionary Source="ms-appx:///Telerik.WinUI.Controls/Themes/Generic.xaml"/>
        <ResourceDictionary Source="ms-appx:///Telerik.ReportViewer.WinUI.Themes/Themes/Generic.xaml"/>
    ResourceDictionary.MergedDictionaries>

ResourceDictionary>


Ta-da! We Have a Custom Theme for the Report Viewer

Try It & Share Your Feedback
New to Telerik Reporting and/or Telerik UI for WinUI? No worries. You can learn more via the Telerik UI for WinUI and Telerik Reporting product pages. Do not wait to try them out—get a free trial now:

    UI for WinUI
    Reporting


The Telerik UI for WinUI controls are already production-ready for Win32 applications. Telerik Reporting is a complete and mature .NET embedding tool for web and desktop applications.

One last thing to keep in mind—the licenses about Telerik UI for WinUI and Telerik Reporting are different individual products. You can purchase both with one of our two best product bundles—DevCraft Complete or DevCraft Ultimate.
We would love to hear what you think, so should you have any questions and/or comments, please share them below. 


Mask It to Perfection With WinUI in Action
2021-10-25T08:34:03Z
Stop making your users guess an input field’s accepted format. Use the new MaskedInput controls for WinUI. Flexible enough to cover your bravest expectations.
There are as many opinions as there are people. And then there are probably millions of forms out there that must be filled. At least one a day.  When it comes to form-filling, people often try to use various formats in the provided input fields. Each user has their unique practices. You know that this leads to even more unique types of issues, right?
Not everybody is able to predict an input field’s accepted format while typing. Using masked inputs helps a lot to avoid almost all types of issues. But not any masked input. There is a particular set of inputs that I can guarantee are flexible enough to cover your bravest expectations.
Born with the Telerik UI for WinUI 1.0, the MaskedInput controls are here and ready to conquer your hearts (or code editors). Let me introduce you.
 
Understanding Input Masking First
In user experience design, an input mask refers to a string template that is created based on a specific input format to prevent transcription errors. If the user tries to enter an invalid character, the masked input element blocks the invalid keystroke. For example, users will not be able to enter letters in a masked phone number field. 
The input masking concept is suitable for capturing user inputs with a specific, standard format, such as IP addresses, credit card numbers, product codes, ID card numbers, among others.
Input masks aim to motivate users to easily enter clean, correct inputs. To do so, such controls need to be flexible, customizable and intuitive enough. 
Got It All Covered With RadMaskedInput
As mentioned at the previous section’s finale, flexibility matters. Covering a rich collection of use-case scenarios is a must here—and not only that, but covering them the right way.
Want to restrict characters?

Sure.
Want the input to be transformed to uppercase letters automatically?

Got it.
Want to allow the users to spread their creativeness in the input field, but a regex to throw away the unallowed characters discretely? Plus updating the user’s property regardless of the invalid UI?

Check.
Want to have advanced validation—be it direct (character by character), or on a regex level over the full text, or when the ValueChanging event is fired and the application logic is triggered?

All your choice.
The great power is in your hands. Aim for the best RadMaskedInputBase inheritor or combine several to build your masterpiece. I will run out of paper if I try to list it all here, so be sure to explore the Mask Types section and the links to each of them in the documentation article of the control. 
A Pinch of Masked Input
I will keep it brief here (in this section).
The RadMaskedInput controls are not playing hard to get. Each type is accessible through an alias pointing to the Telerik.UI.Xaml.Controls.Input namespace (xmlns:input="using:Telerik.UI.Xaml.Controls.Input"). And it only takes a single line of XAML (or C#) code to instantiate it:

<input:RadMaskedTextInput Mask="###" />

 



Mask It Right—Any Time, Day and Night
If you assume that you can mask a DateTime or TimeSpan input with the RadMaskedInput for WinUI—you are correct. So what? Nothing special.
I am kidding! These mask types especially are neat and treat.
They expose various additional properties with which the customization capabilities of the RadMaskedInput control are brought even to the level after the next level.  If you are a control freak, I believe you will enjoy it.
Define the min, the max, the default (DateTime/TimeSpan). Control the navigation to the sections with the arrow keys and determine whether the next part should be automatically selected. Tune the spin steps in each section.
 
About the above GIF—after I enabled the AutoSelectNextPart, I almost stopped using my . I used the up and down keys of my ⌨️ and after I filled the 25 minutes, the control automatically selected the seconds part. And then I started spinning, not my head, but the seconds in the input. 



Find the full set of the properties MaskeDateTimeInput and MaskedTimeSpanInput section of the documentation.
If you sense the ease of use of the DateTime mask type, I guess you will love the power of one very special property — the IsFreeForm. Many users tend to like input masking but are frustrated when trying to type stuff the “correct” way and panic when they see a red border or an error indicator. Wouldn’t it be nice to let the user input whatever they want, and you do the masking all behind the scenes? Different cultures, different datetime formats—not a problem anymore. Let your users hit that Enter button whenever they feel ready, and the control will try its best to recognize their free-form string and convert it to a valid date.
Feature Richness Sneak Peek
Moving on from the DateTime, TimeSpan and the free form variation of the first. After all, I would not want to miss the opportunity to give you hints of the control’s feature richness.
I have mentioned some of the goodies above.
Formatting the Value
Since the RadMaskedInput is an input control (duh!), you may guess it has a Value property. By default, this value trims the prompt characters and the literals defined in the mask. Some mask scenarios, however, may require different formatting of the result value. This is where the ValueFormat property comes in handy. It is applicable for the MaskedTextInput and MaskedIPInput controls and is an enumeration of type MaskFormat.
 
See? I have previously changed the default prompt char to # and I did not fill all empty slots. And then started experimenting with the ValueFormat options in the configurator part on the right. Let us observe the value together:

    With ExcludePromptAndLiterals the value resulted in digits only (all prompt characters and literals were removed).
    With IncludePrompt the value resulted in digits + the default placeholder "_" (all literals—the braces, the dash and the whitespace were removed).
    With IncludeLiterals the value resulted in digits + literals (braces, dashes, whitespace) without the default prompt char.
    With IncludePromptAndLiterals the value resulted in all the literals and the prompts for the non-filled positions being included (practically everything).

    

    P.S. The Text property can always be used, too as it includes the content which the user sees in the UI.

Customizing the PromptChar
The tiny underscore from the above GIF is called PromptChar. It exists to represent the absence of user input. You will not see it as part of the Value unless you are not using the default PromptChar, or the ValueMode property is set to IncludePromptAndLiterals or IncludePromptChar. You will, however, see it in the UI if you have non-filled editable positions. Oh, it will be included in the Value property for the Standard mask types when IncludeLiterals or IncludePlaceholdersAndLiterals are set.
How to define your own prompt character? Simple as that:

this.maskedInput.PromptChar = '#';

Just like I did in the GIF without telling you. 
Changing the Culture
Writing globalized applications is a must nowadays. 
Globalization = Internationalization + Localization

“Internationalization is the design and development of a product, application or document content that enables easy localization for target audiences that vary in culture, region, or language.”


“Localization refers to the adaptation of a product, application or document content to meet the language, cultural and other requirements of a specific target market (a locale).”


— W3C

Understanding the above definitions, you would not want to deliver non-globalized solutions, would you? You also would not want to mask inputs that are not culturally aware. That is why the RadMaskedInput control is designed to provide full globalization support out of the box through the Culture property.
 
(The code snippets of the preceding image can be found at the Globalization section in the documentation.)
Validating the Input
I know I already mentioned the frustration some users feel when they encounter a red border and/or an error indicator. Still, I believe it is far much better to know that something is wrong instead of guessing. See what I am talking about:


 
I think I will stop here … But customization capabilities continue. You can customize the Header, HeaderTemplate, Description. Allow/forbid null or invalid values. Determine whether the prompt character should be treated as a valid input and so on and so forth. 
It is all written in the stars , pardon, the documentation. Be sure to pay attention to it.
Give & Get
Give
Feedback is crucial for continuous improvement. I encourage you to share it. And I am sure I have told you many times that your input is valuable. We do listen. So, find your best ride and do not be shy to stop by.

    Get in touch by email—Drop us a line, for anything related to product or just to say hi at TelerikWinUI@progress.com
    Visit the Feedback Portal—Share any feature request (or bug report) that you might have
    Head to the Telerik Forums—Receive any technical help with the product

Get
Hurry up and get the latest bits of Telerik UI for WinUI! There is a lot more to explore.
Try It Now


Discover the World of Features of RadMap for WinUI
2021-10-20T09:09:01Z
RadMap is a component packed with features that will help your application deliver rich data and map visualizations with ease while keeping development time to a minimum.
A mapping component is essential to any technology in this day and age. We felt it was about time a powerful, feature-rich, native map component entered the WinUI stage, and the result of this intent is RadMap—a component packed with features that will help your application deliver rich data and map visualizations with ease while keeping development time to a minimum.
RadMap for WinUI comes as a part of our Telerik for WinUI 0.5.0 release—you can see what else comes with it in this blog post. Now, I am glad I get the chance to show you an overview of RadMap’s capabilities.
Let us dive in!
Every Trip Starts With a Plan and Some Preparation
The saying goes that if “you fail to plan, you plan to fail.” To get our trip off on the right foot, here is what parts of RadMap we will visit.
First, we will have a look at providers and their specifics. Second, we will look at single- and multi-layer setups. Third, we will declutter our visualizations by clustering items. Fourth, we will take the reins and familiarize ourselves with the built-in controls. Fifth, we will venture into unknown routes. Finally, we will look at how the map can still help us navigate a foreign location without showing an actual geographical map.
First Stop on Our Trip Is “Providers”
To keep this blog post at a manageable length, I will show you the Bing Maps and Open Street Maps providers. You can find the full list in our documentation.
Now let us look at Bing Maps. The setup on RadMap’s side is a few lines. What you may notice there is the “Bing Map Key” value. To get this provider running, you must get your own key from the Bing Maps developer portal. Once you are past that step, replace it in your windows’ XAML and you will be up and running.
<dataVisualization:RadMap x:Name="radMap">  
  <dataVisualization:RadMap.Provider>         
    <telerikMap:BingRestMapProvider ApplicationId="Bing_Map_Key" Mode="Aerial" IsLabelVisible="True"/>     
  dataVisualization:RadMap.Provider> 
dataVisualization:RadMap>


Open Street Maps is even easier to set up. If you want to use the Transport and Cycle maps you can find information on getting a key here. Otherwise, you can jump right in.
<dataVisualization:RadMap x:Name="radMap">     
  <dataVisualization:RadMap.Provider>         
    <telerikMap:OpenStreetMapProvider APIKey="your-api-key" />     
  dataVisualization:RadMap.Provider> 
dataVisualization:RadMap>

If your needs are not fully met by any of the built-in providers, we got you covered. You can create custom providers based on existing ones or brand-new ones, that precisely cater to your customers’ needs.
Second Stop Is the Layering Mechanism
A single layer is what we did in the previous two examples. We have one layer of data and that is the image tiles coming from the service provider. With the layering system of RadMap, we can overlay information layers on top of each other and add more geographical data and/or elements that augment this geographical data like pins, routes, callouts, planes, boats and any form of geometry your application needs.
Here is a screenshot of a map of Washington D.C. showing a street view from Open Street Maps over aerial view from Bing Maps.

Third Stop: Getting a Clearer View
Did you know there are close to 20,000 public and private airports in the USA? That is a lot of pins to place on a map. Thankfully, we have not one, but two solutions that can work in synergy.
Number one is to group items in proximity to each other into clusters. Number two is UI virtualization, which allows the map to only show elements that are currently inside the viewport.
I couldn’t find a file with all the airports in the USA, so we will have to make do with “only” the international ones. Here is RadMap showing said airports on two zoom levels with no pins overlapping thanks to clusterization.


Fourth Stop Is the Built-in Controls of RadMap
They might appear tiny, but they pack a punch. They are there when you need them without getting in the way of the important items the map is visualizing. And when I say they pack a lot, here is what you can do with them: track the geolocation of the mouse pointer, get the scale at which the map is displayed, change the zoom level, pan in four directions, change the type of tiles the provider displays (if it offers more than one).
Fifth Stop Is Finding the Route Between Two Places
Maps have been used for navigation since ancient times. This is still the case today and it is easier than ever. Here is a screenshot showing how to get from New York to Boston. In red is the quickest route to take by car and in blue is the route to take if you are driving a semi-trailer truck, pulling explosive goods, and avoiding tolls. Oh, you get turn-by-turn instructions as well.


Routing and truck routing are part of the services available in the Bing Maps Provider of RadMap. And they are not alone there, keeping them company are search, geocoding and elevation. All these great services are consumable through a convenient API right from your C# code.
On their own, these services are useful and great, albeit only in text/JSON/xml form. To make them truly powerful and unlock their full potential, you need to “translate” them in the language of RadMap—graphical.
Enter the built-in shapes. Thanks to this set of shapes, you can visualize something, as complex as the routes in the screen shot above, in a language that is easily understood by the customer.
Final Stop Is Reading and Displaying Shapefiles
Geographical maps are helpful to get you to a certain destination, and when you get there RadMap can continue being useful. As an example, here is a hotel floor plan which can be of great use not only to find your way around but also when you choose your room. Sea view, mountain view, pool view, whatever your preference is, you can quickly satiate it.

These are some of the scenarios that utilize RadMap and its rich feature set. I am sure there are countless other use cases that I do not even realize exist. You can read the full documentation to get an idea of where RadMap can help you and start building. Go try RadMap, share your feedback, and show us how RadMap empowers your applications. Here are some channels to get in touch:

    Get in touch by email—drop us a line, for anything related to product or just to say hi at TelerikWinUI@progress.com.
    Feedback Portal—share any feature request (or bug reports) that you might have.
    Telerik Forums—if you need any technical assistance with our products, let us know and we will help.

Get the Bits
Don’t wait—try out the latest:
UI for WinUI


Project Reunion: Why Desktop Developers Care
2021-03-26T12:09:02Z
Project Reunion was renamed the Windows App SDK in version 0.8.5.
Project Reunion is intended to consolidate the APIs for the various versions of Windows into a single API. If you’re a desktop developer, even in preview, Project Reunion is already delivering tools that you could be using. And if you’ve ever thought about UWP, then you care very much.
Let me give you some idea of how old I am (but keep reading anyway): When I started creating desktop applications using Microsoft tools, using Windows Forms because it was the only tool available, I had a copy of Dan Appleman’s Visual Basic Programmer’s Guide to the Win32 API. I thoroughly enjoined reading it and learned a lot about Windows in the process. How long ago was that? Part of the book covered how to convert 16-bit calls to 32-bit calls.
Yes, that old.
However, other than the odd call to exchange strings with C DLLs, I never really used the information in that book. All my UI and application development needs were met with Windows Forms, the UI controls that came bundled with it, the Windows COM libraries I could add to my projects and the third-party ecosystem that grew up around Windows Forms.
Since then, we’ve had several different versions of Windows and several different development platforms (WinForms, of course, but also WPF, .NET and UWP). I’ve been able, through various controls and libraries, to remain isolated from the underlying API changes.
The Problem
But there are developers (and you may be one) who haven’t been isolated from those API calls. This is especially true of, for example, the developers who built all those great Windows Forms controls and libraries I used in my applications. The developers who (just to pick some examples at random) developed the Telerik UI for WinForms toolkit. Or the Telerik UI for WPF toolkit. Or the Telerik for UI for Universal Windows Platform (UWP) toolkit. Or the upcoming Telerik UI for WinUI toolkit. And all the other desktop tool vendors are in the same boat.
Part of the reason there are so many toolkits (or, to put it another way, the problem facing those toolkit developers) is the proliferation of Windows 10 APIs—supporting UWP, for example, means supporting the WinRT APIs. This isn’t a trivial task, even on Windows 10 and even with the improved NuGet-based support. Even with that support, developers still have to write version-adaptive code if they want to support earlier versions of WinRT.
And, as desktop developers, you and I care also. If we only accessed UI controls, that might not be true. But we also use various libraries to access non-UI resources like, for example, GeoLocation. The experience of working with GeoLocation in the .NET Framework is very different from doing it in UWP with its WinRT support (in fact, until .NET Framework 4.0, the only way to access GeoLocation was to use WinRT libraries).
But what if those WinRT APIs weren’t segregated? What if there was a single set of APIs available everywhere? All of a sudden, all of these development tools would achieve functionality parity—everyone would support GeoLocation and in the same way (syntax differences aside). More importantly, life would get considerably easier for the developers creating all those wonderful tools, which means more wonderful tools. And, as the growth of cross-platform tools like Xamarin, MAUI, UWP and WinUI shows, there is a craving for a development platform that crosses multiple (if not all) platforms. That becomes a lot more achievable if there’s only one API.
Project Reunion
This is why you care about Microsoft’s Project Reunion and the products it’s already delivering. Project Reunion is intended to consolidate access to Windows features under a single API. In theory, it could mean the end of UWP as a separate development platform: Everything would run everywhere because everything would look alike.
That’s probably too much to expect. But, having said that, Project Reunion has only just got to the 0.5 Preview stage and already includes a unified API for DirectWrite, which provides device-independent text layout. That’s not something you might use directly—instead, you’d count on your UI controls to take care of getting your text on the screen (just like I never wrote to the screen directly when I was creating Windows Forms apps).
But Preview 0.5 also includes MRTCore, a set of objects in the Microsoft.ApplicationModel.Resources namespace for managing resources, including both file resources (files holding bitmap images, XAML, XML, HTML, etc.) and embedded resources (resources in a Resources file like .resw or .resjson). MRTCore objects include ResourceLoader, ResourceManager (which wraps the ResourceMap object, which lists all of your resources) and ResourceContext (which, through ResourceCandidate objects, makes the relevant resources available to your object). That’s a set of objects you could be using tomorrow.
If you want to try out these new tools, your best choice currently is in a WinUI project. WinUI, which allows you to create applications that run both on Windows and WinRT, makes sense for the rollout of Project Reunion (and WinUI is worth trying out for its own sake). Hopefully, the tools that Project Reunion makes possible will become available to all of Microsoft’s desktop development environments—which has the potential of being pretty terrific. Even if I never make an API call in my life.


WinUI: Yes, Another Desktop Framework … But Cooler Than You Might Think
2021-03-24T14:05:26Z
Yes, WinUI is yet another framework for creating desktop applications. But if you want to target “Windows Everywhere” (think Xbox) with some modern development strategies, WinUI is your best choice.




The production version of WinUI 3 is scheduled to come out by the end of March (by the time you read this, it may already be out).
Yay?
Between WinUI, WPF and/or Windows Forms for .NET Core, and MAUI, it’s possible that it may not be obvious which framework you should pick when building your next desktop app. And I’ve omitted at least two Microsoft technologies: Xamarin (because it’s going to be absorbed into MAUI) and Blazor desktop (because it is/will be built on top of the MAUI stack). I’m also ignoring Project Reunion because (a) it’s only in version 0.1 and (b) isn’t intended to replace development tools but to consolidate APIs across Windows platforms.
Even with taking those tools off the table, that’s still a lot of frameworks in play. And it’s probably not going to get better: Richard Lander commented recently that he doesn’t see a “Grand Unified App Model” in the near future. And, as a principal program manager on the .NET Core team, you’d think he’d know.
In all honesty, it might not be the smartest choice (in some sense of the word “smart”) to just keep using whatever toolset you’ve been using so far to build your next desktop app. But it is a choice that has you working with a technology you understand well.
The Case for WinUI
But if you’re willing to consider going to something new … well, WinUI might be your best next choice. Among other benefits (including a very up-to-date developer experience), the version due out in March extends WinUI from supporting the Universal Windows Platform to covering all the Windows device families: Windows 10, Xbox One, Surface Hub, Windows Store, etc. That’s not cross-platform (for Android/iOS/MacOs, you want MAUI), but it may be all you want.
Still, why abandon what you already know? The good news here is that you may already know a lot of WinUI because WinUI is a XAML-based tool. That news gets better: If you’re a WPF developer (or have been using XAML with Windows Forms), then you can adopt WinUI incrementally by exploiting XAML islands. This is also true if you’ve been using React Native, Xamarin.Forms or the Uno Platform.
So, if it’s not going to be painful or expensive, it’s worthwhile to consider what you would get by building in WinUI. The short answer is a modern, fluent development experience (that means Hot Reload so you can see your changes without stopping and restarting your debugger) and a toolkit that exploits all of Windows’ functionality (that means new controls that reflect what current users expect in their UIs—the WinUI controls are a lot more touch-friendly, for example). You can start to get a glimpse of the new controls in this screen grab of the Xaml Gallery (you need Visual Studio to see the gallery in interactive mode). And you can take advantage of the Telerik WinUI toolkit for performant and state-of-the-art controls to extend that gallery.
The WinUI Experience
If the release version isn’t out yet, you can try your luck with the previews (I’ll explain why you need to be lucky in a little bit).
You’ll need the .NET 5 SDK and Visual Studio 2019 Preview 9.2 or later—as I write this, that preview page is downloading Preview 10. In theory, when installing Visual Studio, checking off the .NET Desktop Development should give you the .NET 5 SDK, but that didn’t happen with me. Check to see if the WinUI 3 project templates are present and, if not, download them.
To get the full benefit of the new user experience, from Visual Studio’s Tools menu, select Options | Environment | Preview Features and select Enable UI Debugging Tooling for WinUI 3 Projects. This turns on Hot Reload for XAML files. If you’ve worked with Live Property Tree and Live Visual Tree when building WPF apps, both are still available from Debug | Windows.
When you go to create your project, you’ll have your pick of WinUI project templates for creating any one of desktops apps, class libraries and WinRT components with C++ either for UWP or for Desktop. As I write this, if you want to try out the toolset, I’d recommend “Blank App (WinUI for UWP)” because I couldn’t get any of the “WinUI for Desktop” templates to work (the combination of Visual Studio and WinUI previews has turned out to be a moving target that’s surprisingly hard to hit).
After your app is created, press F5 to start it running and—for some XAML Hot Reload action—then return to Visual Studio, make a change to your XAML file, save your change, switch back to your app and see your change already up and running (changes to your code file will require you to stop and start your debugger).
When the Desktop templates are working, you’ll find that the “create project” experience has a new wrinkle: You’ll be asked for the version of Windows you want to target and for the oldest version of Windows you want support. These two options set the TargetPlatformVersion and TargetPlatformMinVersion settings in your application so you can use those settings to enable and disable functionality, depending on which version of Windows your app is running on (the “oldest version” setting basically specifies what you’re not willing to give up).
It’s a cool technology and, if you’re building Windows desktop apps (and, especially, if you have any WPF/XAML experience), it could well be your future.


Real Time WinUI Dashboard with SignalR Backend
2021-03-12T01:18:22Z
A modern desktop dashboard powered by real-time communications. Let's go.
Life happens in real time and information exchange should be the same way. This is easier said than done and the challenges transcend technology stacks. However, as communications between servers/clients get smarter, developers have been able to leverage sophisticated techniques to build for real-time communications between application platforms. Real-time apps, however, do not need to be for web apps only and can power desktop solutions for various enterprise workflows.
With modern open source frameworks like SignalR abstracting away network stack complexities, developers can focus on real-time app functionalities that enable powerful solutions. Desktop apps often embody busy UI and richness in functionality, quite a classic match for building real-time digital Dashboards—full of data visualizations to keep the user informed. And if building apps to target Windows, desktop app developers will be well served choosing the latest WinUI 3, a native UI framework for modern Windows desktops apps. Let's grab two popular .NET technologies—WinUI 3 to build a realistic dashboard with efficient UI, powered by real-time communications with a SignalR backend.
The SignalR Backend
SignalR facilitates adding real-time communication to web applications running on ASP.NET stack and connected clients across wide variety of platforms. Given a specific server/client pair, SignalR expertly chooses the best transport mechanism for real-time exchanges, with gracious fall-back plans. SignalR provides APIs for bidirectional remote procedure calls (RPCs) between server and client and abstracts away real-time communication complexities. SignalR uses the concept of Hub on the server side—an in-memory object that all clients connect up to for real time communications. The Hub allows SignalR to send and receive messages across machine boundaries, thus allowing clients to call methods on the server and vice versa. In addition to method invocation across programming paradigms, Hubs allows transport of named/strongly typed parameters over JSON or MessagePack data protocols.
The Hub
To build a real-time dashboard, let us first begin with a SignalR powered backend. This backend would, in essence, be the source of truth—collecting data from variety of inputs and pushing out the information to interested connected clients in real-time. First, we have to begin with the server-side SignalR Hub that will power our dashboard. We'll start with a new ASP.NET Core web application project and define a custom Dashboard Hub using the already included server-side SignalR plumbing in ASP.NET Core 3.1 shared framework:

using Microsoft.AspNetCore.SignalR;
using System.Text.Json.Serialization;
using System.Threading.Tasks;

namespace SignalRBackend.Hubs
{
    public class DashboardHub : Hub
    {
        public async Task SendDashboardUpdate(string dashupdate)
        {
            await Clients.All.SendAsync("ReceiveDashUpdate", dashupdate);
        }

        public async Task SendObjectUpdate(ChartData[] chartUpdate)
        {
            await Clients.All.SendAsync("ReceiveObjUpdate", chartUpdate);
        }
    }

    public class ChartData
    {
        public string Category { get; set; }
        public int Value { get; set; }
    }
}

We're declaring two Hub methods here - SendDashboardUpdate() to update some data indicator on a dashboard and SendObjectUpdate() to perhaps update a dashboard object databound to some UI. SignalR Hubs can work with simple data types, as well as, complex business objects. Notice the ChartData class here—while an oversimplification, this demonstrates a SignalR Hub accepting and passing along a C# data object. Serialization/Deserialization comes free. ReceiveDashUpdate() and ReceiveObjUpdate() are two methods this SignalR Hub would look to invoke in every connected client and pass along parameters. 
Next up, we tweak the configurations in ASP.NET Core app's Startup.cs file—essentially adding a SignalR middleware to route appropriate requests to the SignalR Dashboard Hub:

public void ConfigureServices(IServiceCollection services)
{
    services.AddRazorPages();
    services.AddSignalR();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    ...
    ...
    app.UseEndpoints(endpoints =>
            {
                endpoints.MapRazorPages();
                endpoints.MapHub("/dashboardHub");
            });
}

Normally, simply invoking AddSignalR() is enough to establish the SignalR workflow and the Hub works as an in-memory object. This, however, has consequences when the web app if put behind a server farm or load balancing and a common resort is to use a Redis Backplane to keep all connected clients in sync across servers. If however, you do not wish to host SignalR yourself, Azure SignalR Service is here to help—a managed service to take away to complexity of SignalR Hubs and offer lots of scaling. 
Letting Azure Signal Service do the heavy lifting is easy—the web app can stay local, but SignalR Hub communications can be handled by Azure. We simply need to pull in the Azure.SignalR Nuget package and augment with AddAzureSignalR() in our configurations. 


 

public void ConfigureServices(IServiceCollection services)
{
    services.AddRazorPages();
    services.AddSignalR().AddAzureSignalR();
}

All you need to let Azure SignalR Service to manage Hub communications is to pull in the Connection String and Access Token from the corresponding Azure service. .NET CLI provides a handy Secrets Manager tool to store the configuration settings instead of adding them to code—when deployed, this could be an Application setting read from Azure Secrets. 
The Web Client
Next up, let's build the first client that will connect up to our Dashboard SignalR Hub—a web client within the project itself. This is akin to Admin users of the dashboard having a web interface to push information to clients or automate the flow of information. SignalR web clients have some JavaScript dependencies, commonly brought in using Library Manager (LibMan) to get the bits from Unpkg, thus providing content delivery node functionality across usage geographies. The libman.json file spells out dependencies that are brought down to local wwwroot folder:

{
  "version": "1.0",
  "defaultProvider": "unpkg",
  "libraries": [
    {
      "library": "@microsoft/signalr@latest",
      "destination": "wwwroot/js/signalr",
      "files": [
        "dist/browser/signalr.js",
        "dist/browser/signalr.min.js"
      ]
    }
  ]
}

Let us add a little bit of UI to    our web client as in the Dashboard.cshtml page. Assuming we'll be driving a real-time dashboard from the SignalR backend, there is a user input to update a data value and two buttons—potentially to update a Gauge and a Grid that the client dashboard may have.

@page

     
    
        Gauge Value
        
    
     
    
        
            
            
        
    
    
        
            
        
    
    
    
        
    






The simple web interface works for what it meant to do—if desired, we could add any number of inputs so the Admin users could change variety of values to be passed down to client dashboards. Now comes hooking everything up in dashboard.js file, as referenced in our page.

"use strict";

var connection = new signalR.HubConnectionBuilder().withUrl("/dashboardHub").build();

connection.on("ReceiveDashUpdate", function (dashupdate) {
    var encodedMsg = "Dash Update: " + dashupdate;
    var li = document.createElement("li");
    li.textContent = encodedMsg;
    document.getElementById("dashUpdateList").appendChild(li);
});

document.getElementById("sendDashButton").addEventListener("click", function (event) {
    var gaugeupdate = document.getElementById("gaugeValue").value;    
    connection.invoke("SendDashboardUpdate", gaugeupdate).catch(function (err) {
        return console.error(err.toString());
    });
    event.preventDefault();
});

document.getElementById("sendObjButton").addEventListener("click", function (event) {
    var chartdata = [{ "category": "A", "value": 5 }, { "category": "B", "value": 10 }];
    connection.invoke("SendObjectUpdate", chartdata).catch(function (err) {
        return console.error(err.toString());
    });
    event.preventDefault();
});

connection.start().then(function () {
}).catch(function (err) {
    return console.error(err.toString());
});

Few key things going on here. The sendDashButton's click event handler is wired up to grab the user input and pass it back to the SendDashboardUpdate() Hub method. The sendObjButton's click event handler news up a JSON object representing an array of ChartData values—hard coded here, but could easily be driven by user input. The SendObjectUpdate() Hub method is invoked next, passing along the JSON serialized content, which would deserialized/acted upon Hub-side and sent back down to every connected client. We also use the HubConnectionBuilder() to point the web client back to the Dashboard Hub and start up the SignalR connection. That's it, our SignalR backend is now ready for dashboard clients to connect up to and receive updates from the Hub.
WinUI Dashboard
Windows UI Library (WinUI) 3 is in Preview 4 as of writing and is the way of the future for Windows apps. WinUI 3 represents the next generation UI framework that is abstracted from Windows updates and promises to work over .NET Native/.NET runtimes. While there are several ways to target the Windows desktop, choosing WinUI 3 for greenfield projects makes things future proof—combining the best tooling and latest in UI technology stacks.
 



A Dashboard needs UI
WinUI provides a great starting point in terms of UI components, many of which exude the Fluent Design System. But a full-featured desktop dashboard could likely use complex visualizations—Telerik UI for WinUI can help. Telerik WinUI components provide performant feature-rich UI controls that sport intuitive APIs, MVVM support and built-in accessibility/localization. Telerik UI for WinUI suite is growing fast and can provide some of the data visualization needed for our WinUI dashboard.


 
So for our WinUI dashboard, we'll spin up a new WinUI project for a Blank App that runs over UWP and then bring in the Telerik UI for WinUI dependency, either through NuGet package or referencing bits. To give our dashboard a realistic look and feel, let us start with a Radial Gauge. a Linear Gauge and the ubiquitous DataGrid—the world is your oyster to provide the dashboard with all the visualization your app demands. Here is the markup in our MainPage.xaml:




    
        
            
        
        
        
            
            
            
        
    

    
        
            
        
        
            
                
                
                
            
    

    
        
    



What is to be noted are the namespaces that bring in the Telerik assemblies—with the correct references, we can render our Gauges and the Grid. We're also using a local DummyViewModel as a DataContext for the Gauges UI and data binding the Gauge pointers/indicators to a GaugeValue variable. 
Getting Ready Data Binding
We would like the dashboard Grid/Gauges to be data bound. This makes the UI dynamic and for the dashboard data to be set from outside, like from our SignalR backend. Here is the code-behind:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Controls.Primitives;
using Microsoft.UI.Xaml.Data;
using Microsoft.UI.Xaml.Input;
using Microsoft.UI.Xaml.Media;
using Microsoft.UI.Xaml.Navigation;
using Microsoft.AspNetCore.SignalR.Client;
using System.Threading.Tasks;
using Telerik.UI.Xaml.Controls.DataVisualization;

namespace WinUIDashboard
{
    public sealed partial class MainPage : Page
    {
        DummyViewModel vm = new DummyViewModel();

        public MainPage()
        {
            this.InitializeComponent();
            this.DataGrid.ItemsSource = vm.GridValues;
        }
    }

    public class DummyViewModel
    {
        public int GaugeValue { get; set; }
        public List GridValues { get; set; }

        public DummyViewModel()
        {
            this.GaugeValue = 0;

            this.GridValues = new List {
                            new GridData { Category = "A", Value = 20 },
                            new GridData { Category = "B", Value = 30 }
                            };
        }
    }

    public class GridData
    {
        public string Category { get; set; }
        public int Value { get; set; }
    }
}

As evident, the GridData class is the same as the ChartData class the SignalR backend knows how to work with—this being bound to the DataGrid using the DummyViewModel. And the GaugeValue property drives the pointers used in both the Radial and Linear Gauges. With the default data values initialized, we can fire up our WinUI app—and voila, we see a dashboard that is ready for real-time updates.
 
Bringing in Real-Time with SignalR
Now, all that is left to do is for the WinUI app to connect up to the SignalR backend Hub. Let's sprinkle in some real-time communications in our MainPage.xaml.cs:

namespace WinUIDashboard
{
    public sealed partial class MainPage : Page
    {
        DummyViewModel vm = new DummyViewModel();
        HubConnection hubConnection;

        public MainPage()
        {
            this.InitializeComponent();
            this.DataGrid.ItemsSource = vm.GridValues;
            DoRealTimeSuff();
        }

        async private void DoRealTimeSuff()
        {
            SignalRDashSyncSetup();
            await SignalRConnect();
        }

        private void SignalRDashSyncSetup()
        {
            hubConnection = new HubConnectionBuilder().WithUrl($"https://LocalHost or Hosted URL/dashboardHub").Build();

            hubConnection.On("ReceiveDashUpdate", (dashupdate) =>
            {
                var receivedDashUpdate = dashupdate;
                ((ArrowGaugeIndicator)this.RadialGauge.Indicators[0]).Value = Int32.Parse(dashupdate);
                ((LinearBarGaugeIndicator)this.LinearGauge.Indicators[0]).Value = Int32.Parse(dashupdate);
            });

            hubConnection.On("ReceiveObjUpdate", (gridUpdate) =>
            {
                var receivedChartUpdate = gridUpdate;
                this.DataGrid.ItemsSource = gridUpdate;
            });
        }

        private async Task SignalRConnect()
        {
            try
            {
                await hubConnection.StartAsync();
            }
            catch (Exception ex)
            {
                // Connection failed.
            }
        }
    }
}

As evident, we're using the HubConnection to point our app to the SignalR backend's Dashboard Hub—this could be Localhost, an NGrok URL if testing on Localhost outside of machine domain or a remote URL if the SignalR backend web app is hosted in the cloud. Once the connection is started up, we listen in with two client-side event handlers that the SignalR Hub can invoke—ReceiveDashUpdate() updates the pointers/indicators on the two Gauges and ReceiveObjUpdate() receives the updated object collection before rebinding to the DataGrid. The result—a real-time WinUI dashboard that is powered by the SignalR backend. Hallelujah!
 





Conclusion
Desktop apps are here to stay and power a lot of enterprise workflows. When building for Windows desktop, WinUI 3 represents the future—a modern UI framework that rides over several runtimes and welcomes various programming paradigms. Desktop apps also need not be boring and can feature complex dashboard powered by rich data visualizations. And what good is data if not real time? SignalR is a wonderful piece of technology that abstracts network stack complexities to enable real time communications across app platforms. SignalR sits on top of ASP.NET technology stack and can empower real-time solutions across variety of clients, including desktop of course. 
All the needed technology is here—modern Windows desktop app in the form of a WinUI dashboard powered by real-time communications from a cloud-hosted SignalR backend. What's left to do is to reimagine workflows and sprinkle in some real-time magic. Cheers to that.


Future of Desktop
2020-11-11T22:55:06Z
We recap the Future of Desktop webinar, unpacking the latest in Windows Desktop development, developer preferences, tooling and Q&A.
Building apps for modern web and mobile platforms is pretty cool. However, a staggering percentage of enterprise workflows continue to be driven by native Desktop applications. This was the motivation for us to host a webinar on Windows Desktop technologies—we dived into the state of present Desktop development and peeked into what the future holds.
Windows Desktop apps have traditionally run on .NET Framework. But how can Desktop apps be labeled as legacy if they are powering current business processes? Modern Windows Desktop apps actually run on latest .NET Core 3.1 and the just-released .NET 5. Windows app developers enjoy mature tooling and rich ecosystems. Desktop is truly alive and well.
For part of the webinar, we brought in Olia Gavrysh—program manager at Microsoft responsible for WPF/WinForms tooling. We explored all available Windows Desktop technologies and looked at latest tooling updates. This was a good day for Desktop developers—you can catch the whole recording below:

The Will of Developers
A lot has been evolving for Windows Desktop developers, and folks naturally have opinions. We asked three key poll questions to get a feel of how developers felt about the reality of Desktop development—this provides a community pulse.
Poll 1: If you are to start a greenfield Desktop project today, what framework would you write it in?


 
Poll 2: .NET 5 is a big reunification effort. When do you want to jump on to .NET 5?


 
Poll 3: Do you have "legacy" Desktop apps running on .NET Framework that could be migrated to .NET 5?

Honest Q&A
Windows Desktop developers are a passionate bunch. When we open the floor, honest and open conversations follow. There were a ton of questions asked during the webinar, which we tried answering as quickly as possible. Here are handful of questions that warrant being answered openly for developer benefit. And for the sake of everyone's time and brevity, we're keeping answers to one sentence each. Want a longer conversation? Please comment and we'll chime in.
Q: What's the big deal with Designer for WinForms? 

A: Modern WinForms run on .NET Core, while Visual Studio is a .NET Framework app .. it took a lot of engineering to pull off the Designer.
Q: How can we use the new WinForms Designer? 

A: It is available in VS 2019 Preview 5 and 6 ... soon to be mainstream.
Q: Is Designer indispensable for WinForms developers? 

A: Kind of ... and now all Telerik WinForms UI shows up in the Designer.
Q: For a .NET 4.8 app, should we migrate to .NET Core 3.1 and then to .NET 5? 

A: About the same effort ... so choose between .NET 3.1 LTS or the new .NET 5.
Q: Will .NET 5/Win UI replace Xamarin? 

A: Nope ... Xamarin becomes part of .NET to enable cross-platform solutions.
Q: Is WinForms dying? 

A: Quite the contrary ... runs on latest .NET.
Q: Can I share code between WPF and Xamarin.Forms? 

A: Yes, through WPF renderers for Xamarin.Forms and if following MVVM design pattern.
Q: Would .NET MAUI have a Desktop play? 

A: The next evolution of Xamarin.Forms is slated to support MacOS and Windows Desktop (potentially over Win UI).
Q: Doesn't .NET Core mean cross-platform Desktop solutions? 

A: The .NET runtime is cross-platform, not the UI stacks ... WPF/WinForms/Win UI run on Windows only.
Q: Will VB.NET be supported in .NET 5? 

A: Yes.
Q: Will C++/CLI be supported in .NET 5? 

A: Yes, just like in .NET Core 3.1 and it is Windows only.
Q: Is deployment story any different between .NET Framework and .NET 5? 

A: Not really ... ClickOnce is supported in both .NET 3.1 and .NET 5.
Q: What are some latest updates for WPF tooling in VS? 

A: Hot Reload + Binding Failures + Design-time Data + Improved Toolbar.
Q: Does the Telerik NotifyIcon control work on Windows 7/8 in addition to Windows 10? 

A: Yes.
Q: Can I write a Win UI app entirely in C# without using XAML? 

A: Yes.
Q: How can I try the latest Win UI? 

A: In VS 2019 Preview ... which can coexist next to regular VS 2019.
Q: Is UWP dying in favor of Win UI? 

A: Nope, Win UI is the UI stack sitting on top of UWP and Win 32 platforms.
Q: Win UI is exciting. Can we expect more Telerik UI? 

A: Absolutely.
Q: What are some essential tools for modern Desktop developers? 

A: Latest Visual Studio + Telerik UI + Fiddler Everywhere.
Q: Can I use Blazor to build Desktop apps? 

A: Yes, it is an option ... either as a pinned PWA app or through web shells like Electron/WebView.
Rejoice Desktop Developers
So that's it folks. As you see, modern Windows Desktop development is alive and kicking. With options to run apps on .NET Framework, .NET Core 3.1 and .NET 5, Desktop apps provide developers a ton of freedom to devise solutions that fit enterprise workflows and deploy them accordingly. With matured tooling from Microsoft and polished UI components from our Telerik suites, Desktop developers have all the ammunition to go change the world. Let's do it.

Telerik Blogs | Desktop | WinUI

What’s New in R2 2023 with Telerik Desktop and Mobile Components

Telerik UI for .NET MAUI

Calendar

PDF Viewer Component

Chat Component (Conversational UI)

SlideView Component

Rich Text Editor Component

TreeView

DataGrid Empty Template Support

DataGrid DataTable support

.NET 6 & .NET 8 Support

Check out the Detailed Release Notes

Telerik UI for WPF

RadSlideView and RadPipsPager components

Windows 11 Compact Theme

RadDocking: Move Panes Between Multiple Docking Instances

SyntaxEditor: Search UI Enhancements

RadPivotGrid LocalDataSourceProvider Hierarchies

Support for .NET 8 Preview

Telerik UI for WinForms

Heat Map

Visual Studio 2022 Dark Theme

Scheduler Appointment Styles

Line Numbering in RichTextEditor

Support for .NET 8 Preview

Other Improvements

Telerik UI for WinUI

New TimeBar Component

Telerik UI for Xamarin

Xamarin DataGrid Enchantment: Empty Template Support

Telerik Document Processing Libraries

New PDFProcessing Improvements: Multiple Image-Related Enhancements

New SpreadStreamProcessing Improvements: Support for Importing Rich Text as Plain Text

Document Processing Libraries: Fixes and Quality Improvements

Join Us for Release Webinar (and More)

Progress Telerik .NET Web, Desktop & Mobile Products R2 2023 Release Webinar | June 8

Join Us on Twitch

What’s New in Telerik Desktop & Mobile with R1 2023

Telerik UI for WinForms

Windows 11 Theme

ToolbarForm

TaskbarButton

SyntaxEditor: Word Wrapping

.NET 7 Support

Revamped Icons

WinUI

Calculator

CalculatorPicker

.NET 6 and Windows App Sdk 1.2 Support

Check out the Detailed Release Notes

Telerik UI for WPF

OfficeNavigationBar

Map: Vector Tiles Support

ScheduleView: Improve Performance with a Lot of Resources

RichTextBox: New Selection Mode

PivotGrid: Load Data from OLAP Cube on Demand (Lazy Loading)

ChartView: Create Histogram Charts with ScatterRangeBarSeries and ChartHistogramSource

End of .NET 5 Support

Other Features

Check out the Detailed Release Notes

Telerik Document Processing Libraries

New Encryption Mode Supported in RadPdfProcessing Library

New Search API in the RadPdfProcessing Library

New Fields in RadWordsProcessing

Telerik UI for .NET MAUI

New .NET MAUI ToolBar Control

.NET MAUI ImageEditor

New SignaturePad Control for .NET MAUI

RadProgressBar for .NET MAUI

UI for .NET MAUI Accordion

New Feature in DataGrid—Frozen Columns

Telerik UI for Xamarin

Xamarin DataGrid Enchantment: Support for Scrolling to a Specific Item

New Functionality in our SideDrawer Component for Xamarin

Try Them Out & Share Your Feedback

Join Us for Release Webinar (and More)

Progress Telerik .NET Web, Desktop & Mobile Products R1 2023 Release Webinar | January 26

Join Us on Twitch

Progress Kendo UI R1 2023 Release Webinar | January 31