With this release (v18.2), we have enhanced the rendering abilities of our Rich Text Editor control (for both WinForms and WPF) and Word Processing Document API. New features/capabilities include the following: 

Right-To-Left Text Direction Support

As some of you already know, the DevExpress Rich Text Editor and Word Processing Document API now supports RTL languages (right-to-left text direction).  

Shapes

New implementation allows you to view documents with all shape types: from simple lines and rectangles, to complex shapes with advanced effects. You can change a shape’s fill and outline colors using the Rich Text Editor’s (WinForms and WPF) built-in UI elements. 

Paragraph Borders

We now give you the ability to display paragraph borders. You can render documents with paragraph borders as needed. 

Let us know your thoughts

Your feedback is valuable. What do you think about these new features? How likely are you to use them in an upcoming project? Feel free to make new suggestions using the DevExpress Support Center or in the comments below. 

We just released three new clients for Xamarin.iOS, Xamarin.Android and UWP applications. If you’re building apps for Xamarin, you can use these clients within your projects. Exceptions generated within Xamarin.Forms code will also be caught.

Getting Started 

To start monitoring your Xamarin apps with Logify, you simply need to add the Logify.Alert.Xamarin.iOS, Logify.Alert.Xamarin.Android or Logify.Alert.UWP library to your project. Once added, you will then need to configure Logify using the following code snippet at the start point of your application:

LogifyAlert.Instance.ApiKey = "YOUR_API_KEY";
LogifyAlert.Instance.StartExceptionsHandling();

Application start points are as follows:

• iOS: beginning of the Main method
• Android: beginning of the OnCreate method of the MainActivity
• UWP: beginning of the App class constructor.

Client Сustomization

Sample Reports

I’ve described how to configure your Xamarin app and begin using Logify. Let me now turn my attention to its report engine. Here are four sample reports generated from a small test application:

Sample iOS Log

Sample Android Log

Sample UWP Log

Sample Xamarin.Forms Log

As you can see these reports contains detailed information about individual exceptions and the environment wherein the exception was raised.

Data filtering is one of the most popular interactive features of our WPF controls. In an effort to improve usability, we analyzed user interaction patterns for this functionality.

In v18.2, we added the following data filtering features to the Data Grid:

• Filter Elements
• New Data Filter Editor
• New Date Operators
• Record Count Display
• Predefined Filters

In upcoming releases, we will support these features in other data-bound WPF controls, including Charts and Pivot Grid.

Filter Elements

Using Filter Elements, you can build your own UI to filter control data. As an example, here is a UI that uses Filter Elements for a filtering panel displayed next to the Data Grid.

This is an overview of the Filter Elements available in v18.2:

Checkbox
Radio List
Checked List
Checked Tree List
Predefined Filters
Range
Calendar

It is easy to connect Filter Elements to your control. Three steps are required:

1. Add your Elements to a container (for instance the Accordion Control)
2. Specify the field names of columns you want to filter, using the FieldName properties
3. Set the attached property FilterElement.Context on the container to associate it with the filtering context of the data-bound control. The Filter Elements use this context to retrieve values, formatting settings and other details, and the context is configured with criteria from the Filter Elements in return.

Here is a XAML example:

<dxa:AccordionControl
  dxfui:FilterElement.Context="{Binding Path=FilteringContext, ElementName=grid}"><dxa:AccordionItem Header="Price ($)"><dxfui:RangeFilterElement FieldName="Price"/></dxa:AccordionItem><dxa:AccordionItem Header="Trademark"><dxfui:CheckedListFilterElement FieldName="TrademarkID"/></dxa:AccordionItem><dxa:AccordionItem Header="Transmission Type"><dxfui:RadioListFilterElement FieldName="TransmissionTypeID" /></dxa:AccordionItem></dxa:AccordionControl><dxg:GridControl Name="grid"/>

You can see a sample setup in the Filtering UI demo. If you are reading this post on a machine that has the WPF demos installed, please follow this link to start the demo.

Documentation is available for Filter Elements.

New Data Filter Editor

We received many requests for enhancements to the Filter Editor. In order to deliver these without introducing breaking changes, we implemented a new Filter Editor. The old editor is still the default in v18.2. To enable the new editor, set the property DataViewBase.UseLegacyFilterEditor to false.

In the new editor you can now use a search box to quickly find a required field:

You can select values from the data source to configure a filter. Each value in the list displays a record count.

You can apply predefined filters from the selection menu:

The Filter Editor demo shows this functionality in action. If you are reading this post on a machine that has the WPF demos installed, please follow this link to start the demo.

Here is the link to the feature documentation.

New Date Operators

In previous versions, if you applied a filter that included several dates…

… the Filter Panel displayed an expression similar to this:

In v18.2 we added the Is Between Dates and Is On Dates operators to optimize the expression:

You can also use these date operators in the new Filter Editor:

Record Count Display

When you apply a filter, it can be useful to know how many records match the value you’re filtering for. The Excel-inspired Filter Drop-Down now displays record counts next to filter values:

You can enable this feature for a column using the property ColumnBase.FilterPopupMode, or for a view using DataViewBase.ColumnFilterPopupMode– set these properties to ExcelSmart. The new Filter Editor and the Filter Elements support this feature, too.

This link runs the demo Excel Style Filtering if it is installed on your machine.

Predefined Filters

Our Filtering UI allows end users to create complex filters, but you may want to save them time by providing predefined filters out of the box. You can now specify such filters using the property BaseColumn.PredefinedFilters:

<dxg:GridColumn FieldName="MPGCity"><dxg:GridColumn.PredefinedFilters><dxfui:PrefefinedFilterDescriptionCollection><dxfui:PredefinedFilterDescription Filter="?p>=25" Name="More than 25" /><dxfui:PredefinedFilterDescription
        Filter="?p>15 AND ?p<25" Name="From 15 to 25" /><dxfui:PredefinedFilterDescription Filter="?p<15" Name="Less than 15" /></dxfui:PredefinedFilterDescriptionCollection></dxg:GridColumn.PredefinedFilters></dxg:GridColumn>

You can then show these filters in the PredefinedFiltersElement:

You can select predefined filters in the new Filter Editor as well as the Excel-inspired Filter Drop-Down.

What’s Next?

v18.2 supports the enhanced filtering functionality for the Data Grid, including the TreeListView. In future releases we will support the same feature set for Instant Feedback UI Mode and Virtual Sources, and we will make the functionality available in other data-bound DevExpress WPF controls. Additionally, we plan to introduce these features:

• Conditional Format Filters
• Grouped filter items in the Excel-inspired Filter Drop-down, with results displayed as a checked tree list
• Enhancements to the Filter Editor API

Your Feedback Is Important To Us!

Many of the features described in this post are based on your feedback – thank you! Please feel free to make new suggestions in the comments below or by opening Support Center tickets.

Please take a moment to answer the following survey question:

Great news - our upcoming release will include a highly requested feature for both our ASP.NET DateEdit and Calendar Controls: a new mode that allow your end-users to select only the month and year portion of the date. Check this animation to see it in action:

Scenarios

There are many scenarios like "credit card expiration dates" that require an end-user to select only the month and year. The new month-year picker mode helps with these types of scenarios.

You can also use it to filter other controls like the GridView:

How to Use

To set up picker mode, use the new PickerType property. This property allows you to set one of these values: ['NotSet','Days','Months','Years','Decades'] (NotSet is the default value.)

Data Annotation Support

You can also set the PickerType property using Data Annotation attributes. Usually Data Annotation attributes are available with our ASP.NET MVC controls but now you can use them with the DevExpress ASP.NET WebForms Editor controls inside the DevExpress ASP.NET FormLayout control too:

[DatePickerType(DatePickerType.Months)]
public DateTime FilterDate { get; set; }

Let's take a look at the different PickerType values:

Days View

If PickerType is set to Days then the control will display the "Days" view and you can select a specific day, for example "11/22/2018":

Months View

With the Months setting, you can restrict the control to select months only:

The Months is the minimal available view. This means that an end-user can select only the specific month, for example, "Dec 2018". You cannot select the day in this view, however, because this control will bind to a variable of the DateTime type, it will set the day value to 1, the first day of the month.

Years View

The Years value let's you restrict the date selection to years only:

Initial & Max View

We've also added two new properties that let you set the initial and maximum view of navigation between months, years, and decades:

• ASPxDateEdit.CalendarProperties.FastNavProperties.InitialView
• ASPxDateEdit.CalendarProperties.FastNavProperties.MaxView

Demos

Take a look at the online demos:

• WebForms: https://demos.devexpress.com/ASPxEditorsDemos/DateTime/MonthYearPicker.aspx
• MVC: https://demos.devexpress.com/MVCxDataEditorsDemos/Editors/MonthYearPicker

I'd like to thank all the customers who provided us their usage scenarios for the new feature. What are your thoughts on the new month-year picker feature? Drop me a line below, thanks!

When we say "your feedback is important for us", we mean it. In fact, the new command column customization enhancements for the DevExtreme DataGrid and TreeList components were added directly as a result of your feedback. So thanks for your help, and keep sending us your comments.

If you're not familiar with the term, command columns are those unbound columns that display the buttons for CRUD operations, selection, and the adaptive column:

With these new enhancements, you can now set the width, position, cell templates, and customize the command buttons too. Let's take a closer look at how you can use these new options.

Note: This feature is available in DevExtreme for Angular, Vue, React, jQuery, and ASP.NET MVC and ASP.NET Core.

Width

To set the width of the command column, declare it in the columns array for the component, then declare the value:

{
    columns: [ 
        ..., 
        { 
            type: "selection", 
            width: 200 
        } 
    ] 
}

Position

To define where a command column is to be displayed in the component, simply declare and insert it into the columns array at the required place:

{ 
    columns: [ "title", "firstName", "lastName", 
        { 
            type: "selection"    
        } 
    ] 
}

Cell Template

Templates are a great way to extend the UI and functionality of your component. Now you can use the cellTemplate or headerCellTemplate properties to customize the look and feel of a command column. Simply add the column declaration as before, then add either of these two new properties to define how the column behaves.

{ 
    columns: [ …, 
        { 
            type: "adaptive", 
            cellTemplate: function() { 
                // render the custom cell content here 
            } 
        } 
    ] 
}

Customize Command Buttons

We've added several options to customize the command buttons too:

Add custom command buttons in default appearance

To customize command buttons, first declare a command column to contain buttons, and then define the buttons you need as an array within that column declaration. Some buttons are pre-defined (edit, delete, and so on), others you can fully declare an an object in that button array.

{ 
    columns: [ …, 
        { 
            type: "buttons", 
            buttons: [ "edit", "delete", { 
                text: "My Command", 
                icon: "...", 
                hint: "...", 
                onClick: function(e) { 
                    // execute your command here 
                }, 
                cssClass: "..." 
            }], 
        } 
    ] 
}

Add custom command buttons in custom appearance

To define a custom look, set up the template property:

{ 
    columns: [ …, 
        { 
            type: "buttons", 
            buttons: [ "edit", "delete", { 
                template function($cellElement, options) { 
                    // render your custom control here 
                } 
            }] 
        } 
    ] 
}

Hide the built-in command column’s command buttons

To hide a built-in command button, do not specify it in the buttons array. In other words, only those buttons you specify in the array will be displayed:

{ 
    columns: [ …, 
        { 
            type: "buttons", 
            buttons: ["delete"] // hide the default `edit` button 
        } 
    ] 
}

Hide the built-in editing buttons from a specific row

The editing behavior of the DataGrid and TreeList is defined through an editing object. You can now change the behavior of the editing object to allow for when a row can be updated, deleted, or added by specifying specifying a function predicate for the allowUpdating, allowDeleting, and allowAdding properties. Return false, the relevant editing feature is disabled; return true, the feature is enabled.

{ 
    editing: { 
        mode: "row", 
        allowUpdating: function(row) { 
            return row.data.id % 2 === 0; 
        }, 
        allowDeleting: function(row) { 
            return row.data.id % 2 === 0; 
        }, 
        allowAdding: function(row) { // only for TreeList 
            return row.data.id % 2 === 0; 
        } 
    } 
}

Add custom command column

Each column can have its own set of buttons, simply declare the new buttons columns in the columns array:

{ 
    columns: [ 
        { 
            type: "buttons", 
            buttons: ["edit", "delete"] // default editing buttons 
        }, "firstName", "lastName", 
        { 
            type: "buttons", 
            buttons: [// specify your custom buttons here] 
        } 
    ] 
}

NOTE: When you declare a buttons column, it replaces the default column that contains the editing buttons. Make sure you declare this editing column explicitly as shown in the code above.

Limitations

Currently, the feature is limited in that you cannot hide the 'expand row details' arrow from a specific row.

Test It Now (and provide feedback)

Experience the online demo. Then test-drive the public release on your local machine. Use the npm package:

npm install --save devextreme@18.2

Then let us know your experience with the DataGrid or TreeList's command column customization enhancements.

Join the Webinar

Sign up for the upcoming "New in v18.2 - DevExtreme HTML / JS Controls" webinar where:

• you'll see all the new features/tools/components in v18.2 and
• you can ask questions and interact with our devs

Register today: https://attendee.gotowebinar.com/register/1534319392881688322

Your Feedback Counts

We’d like to hear from you about your development plans and needs. Feel free to leave comments below, open Support Center tickets for detailed discussions or take part in conversations in our GitHub repository.

Document Viewer – Word-Inspired Navigation Pane

We updated the WPF Document Viewer with a new Microsoft Word-inspired Navigation Pane, which is enabled by default in v18.2. The new pane combines the Document Map, Pages (this used to be Thumbnails) and Search Results panels in a tabbed interface:

The functionality of this panel is similar to the one in Microsoft Word. For example, the search functionality operates across all tabs, highlights items in the Document Map and filters page thumbnails to display only those document pages that contain the keywords:

The property DocumentPreviewControl.ShowNavigationPane defines whether the pane is visible. To switch back to the old toolbar appearance and show the Document Map, Thumbnails and Search panels separately, disable the property DocumentPreviewControl.UseOfficeInspiredNavigationPane in XAML:

<dxp:DocumentPreviewControl x:Name="documentPreview1"
  UseOfficeInspiredNavigationPane="False"></dxp:DocumentPreviewControl>

This property not only changes the dock panel appearance, but also affects the toolbar items. Separate items per panel are the old style (UseOfficeInspiredNavigationPane=False), a single Navigation Pane item is the new style (UseOfficeInspiredNavigationPane=True) and the new default.

The DocumentPreviewControl has the property NavigationPaneSettings to control the behavior in detail:

• NavigationPaneSettings.ShowDocumentMapTab– Show/hide the Document Map tab
• NavigationPaneSettings.ShowPagesTab– Show/hide the Pages tab
• NavigationPaneSettings.ActiveTab– Define or retrieve the currently visible tab
• NavigationPaneSettings.UseCaseSensitiveSearch– Search option
• NavigationPaneSettings.SearchWholeWords– Search option

Report Designer – Query Builder Light Mode

If you have used our WinForms Report Designer, you may already be familiar with the Light Mode of the Query Builder available on that platform. In a nutshell, this mode disables some of the more complex options provided by the Data Source Wizard in order to make the wizard more accessible to users who don’t know much about RDMBS structures.

In v18.2, the Query Builder in the WPF Report Designer supports Light mode. Just set QueryBuilderLight to True in your XAML:

...<dxrd:ReportDesigner Name="reportDesigner1"
  DataSourceWizardSettings="{dxda:DataSourceWizardSettings
    SqlWizardSettings={dxda:SqlWizardSettings QueryBuilderLight=True}}"/>

As an example of the limited feature set the Query Builder offers in this mode, the SQL editing pane is removed from the UI as a result:

An extra feature of the Light mode is the support for an IDisplayNameProvider implementation to customize table and column names, or suppress them from the UI. You can see this in the screenshot above, where table and field names have the postfix _Custom. Details about this functionality can be found here– you need a simple class that implements the two methods of the interface. Then you can apply the implementation to the Report Designer by adding an entry to the ServicesRegistry like this:

...
xmlns:dxda="http://schemas.devexpress.com/winfx/2008/xaml/dataaccess"
xmlns:dxrud="http://schemas.devexpress.com/winfx/2008/xaml/reports/userdesigner"
xmlns:dxdw="clr-namespace:DevExpress.DataAccess.UI.Wizard;assembly=DevExpress.DataAccess.v18.2"
xmlns:dxdata="clr-namespace:DevExpress.Data;assembly=DevExpress.Data.v18.2"
...<dxrd:ReportDesigner Name="reportDesigner1"><dxrd:ReportDesigner.DataSourceWizardSettings><dxdw:DataSourceWizardSettings
    SqlWizardSettings="{dxdw:SqlWizardSettings QueryBuilderLight=True}"/></dxrd:ReportDesigner.DataSourceWizardSettings><dxrd:ReportDesigner.ServicesRegistry><dxda:TypeEntry ServiceType="{x:Type dxdata:IDisplayNameProvider}"
      ConcreteType="{x:Type local:MyCustomNameProvider}" /></dxrd:ReportDesigner.ServicesRegistry></dxrd:ReportDesigner>

Your Feedback Counts

What do you think about these improvements to our WPF Reporting tools? Is anything missing in the product line? To give us some quick feedback, please submit your answers to this short survey:

We are constantly improving the API of our Data Grid and Tree List to make it easier to use and more powerful for customization scenarios. Examples of this work are described in posts about our Drag & Drop, Master/Detail, and Data Paging features, and most recently we introduced some new data filtering functionality.

This post is about the Custom Cell Editor API. We had requests to support end-user navigation and data validation in non-DevExpress editors, including your own custom ones.

End-User Navigation

In previous versions, implementing end-user navigation in custom editors was harder than it should be, because the Data Grid overrode navigation keys internally. It was necessary to handle the event GridControl.PreviewKeyDown, find your editor in the visual tree and manually focused the inner elements.

In v18.2 we added some special events to make this easier.

An Example: Using a ListBoxEdit

To specify a custom cell editor, you use the CellTemplate property.

<dxg:GridColumn FieldName="City"><dxg:GridColumn.CellTemplate><DataTemplate><dxe:ListBoxEdit x:Name="PART_Editor"
        ItemsSource="{Binding RowData.Row.Cities}"/></DataTemplate></dxg:GridColumn.CellTemplate></dxg:GridColumn>

With this custom editor in place, it makes sense to enable the Up and Down keys to navigate the items in the editor.

Starting with v18.2, you can use the event GetActiveEditorNeedsKey. Here’s how to reserve the Up and Down keys for the editor:

void TableView_GetActiveEditorNeedsKey(object sender, DevExpress.Xpf.Grid.GetActiveEditorNeedsKeyEventArgs e) {
  if (e.Key == System.Windows.Input.Key.Up ||
      e.Key == System.Windows.Input.Key.Down)
    e.NeedsKey = true;
}

When an end user clicks a cell, the default behavior is only to activate the cell editor. The Grid grabs the click event and the editor doesn’t receive it, so the click does not select an item inside the editor. However, now you can handle the new event ProcessEditorActivationAction to make the Data Grid raise the click event again after handling it. The cell editor can then handle the event as well.

void TableView_ProcessEditorActivationAction(object sender,
  DevExpress.Xpf.Grid.ProcessEditorActivationActionEventArgs e) {
  if (e.Column.FieldName == "City" &&
      (e.ActivationAction == ActivationAction.MouseLeftButtonDown &&
        e.MouseLeftButtonEventArgs.LeftButton ==
          System.Windows.Input.MouseButtonState.Pressed))
    e.RaiseEventAgain = true;
}

A complete sample project is available in this GitHub repository.

A Second Example: Using a Slider

Sometimes you need to use separate editors to display and edit values. You configure the CellDisplayTemplate and CellEditTemplate properties to achieve this.

In this example, bars are used to display values but a Slider is shown to edit them.

End users can activate an editor in several ways:

• Click the cell
• Press Enter or F2
• Start typing

Sliders work with +/– (plus, minus) keys, so it would be useful to activate the editor when these keys are pressed.

Using the new event GetIsEditorActivationAction, you can specify actions that activate an editor.

void TableView_GetIsEditorActivationAction(object sender,
  GetIsEditorActivationActionEventArgs e) {
  if (e.Column.FieldName == "HoursActive" &&
      e.ActivationAction == ActivationAction.KeyDown)
    e.IsActivationAction = IsSliderCommand(e.KeyDownEventArgs.Key);
}

bool IsSliderCommand(Key key) {
  switch(key) {
    case Key.Add:
    case Key.Subtract:
    case Key.OemPlus:
    case Key.OemMinus:
      return true;
    default:
      return false;
  }
}

If you want the +/- keys to not only activate the Slider but increase or decrease the value at the same time, handle the event ProcessEditorActivationAction that was already used in the previous example.

void TableView_ProcessEditorActivationAction(object sender,
  ProcessEditorActivationActionEventArgs e) {
  if (e.Column.FieldName == "HoursActive" &&
      e.ActivationAction == ActivationAction.KeyDown)
    e.RaiseEventAgain = IsSliderCommand(e.KeyDownEventArgs.Key);
}

You can see a sample setup in the Cell Editors demo included in your installation. If you are reading this post on a machine that has the WPF demos installed, please follow this link to start the demo.

Data Validation

We now fully support data validation for non-DevExpress editors used in cell templates, including validation on the Grid control level.

Using the same Slider example as before, you can now prevent end users from setting incorrect values. Simply handle the event GridColumn.Validate, detect invalid values and use the validation API to provide feedback.

void colHoursActive_Validate(object sender, GridCellValidationEventArgs e) {
  double value = Convert.ToDouble(e.Value, e.Culture);
  if (value <= 0 || 1000 < value)
    e.SetError("The Hours Active value must be greater than zero and less than or equal to 1000", ErrorType.Default);
}

To Summarize

You can now use CellTemplate, CellDisplayTemplate and CellEditTemplate to specify any custom editor control with navigation and validation support.

We also improved one small technical detail. You know that you can set an editor name to PART_Editor to make the Data Grid automatically adjust its appearance and synchronize the editor with the source field specified by the ColumnBase.FieldName or ColumnBase.Binding properties.

In previous versions, when you set PART_Editor, the Data Grid ignored any binding specified on your custom editor. In v18.2, you can specify PART_Editor and a binding simultaneously, and the Data Grid will still adjust the appearance but use your own binding.

Finally, we recommend reading the In-Place Editors document about all different cell editor customization techniques.

Your Feedback Counts

All the features and usage scenarios described in this post are based on your feedback. Please let us know if you have any thoughts about our implementation. Do you have other ideas for enhancements to our Data Grid and Tree List?

Join the Webinar

If you would like to see all the new v18.2 WPF features in action and ask our devs questions, please sign up for the upcoming webinar.

Here is the link to register today

The Drawer component is a fairly new UI component which, these days, is used widely on apps and websites optimized for phone-sized devices.  The Drawer is a panel on the left or right (or even top or bottom) side of the screen.
In its normal state this panel is not visible, but when triggered by e.g. a button, it slides over the main view content of your app to provide you with additional features.

One of the most well known examples is the Hamburger menu.

For all of you familiar with CSS/JavaScript development, you know it’s absolutely possible with CSS and a tiny bit of JavaScript to accomplish this task, but it’s a bit of work. In fact, I’ve done a conference session on this particular subject some time ago which some of you might have attended to.

In our v18.2 release we’ve decided to include this Drawer as a component with some useful features.

Note: This feature is available in DevExtreme for Angular, Vue, React, jQuery, and ASP.NET MVC and ASP.NET Core.

How does it work?

It’s quite simple to add a Drawer to your App. Just wrap the main view content inside the dx-drawer. This will make sure  that the Drawer drops a nice shadow over the main view content and it will properly update size and position when opened.

The drawer’s content is specified inside a dxTemplate.

<dx-drawer>     <div *dxTemplate="let data of 'template'"> 
        Drawer Panel Content </div> <div> 
        Main Content </div> </dx-drawer> 

The example above is for Angular. However, this applies to React, Vue and jQuery as well.

Customizing the appearance and behavior

There are a couple of really nice things that can be configured like:

Drawer position

The position of the Drawer can be set to:

• left
• right
• top
• bottom

Drawer open behavior

The open behavior determines how the Drawer appears and what happens with the main view content.

The following options are available:

• push
  the Drawer causes the main view content to be displaced (pushed out of the view area)
• shrink
  The main view content is being resized
• overlap
  The Drawer overlaps the main view content

Drawer reveal mode

This determines how the Drawer will show up:

• slide
  The drawer is sliding during the open/close animation
• expand
  The drawer is static during open/close. Only the width is animating

Some other interesting behavior options are:

• Enable/Disable Drawer shadow
• Specifying a minSize and maxSize
• Setting the duration of the animations
• Target element to where to position the Drawer
• Response options to determine whether to always show the Drawer (persistent) or to hide/show it.

Are there limitations?

In some mobile apps, a navigation panel/drawer can be shown/hidden with a swipe gesture. This feature makes it difficult to enable swipe gestures in the main view content as well. This is not supported in this version of the Drawer and we consider this to be a bad practise.

Try it?

You can test the Drawer Component by visiting our DevExtreme Demo Center by clicking here for the left and right positions, and click here for the top and bottom positions.

Alternatively, our v18.2 release is already available for our customers so login at our web-site and head to the My Downloads section from where you can download and install DevExtreme v18.2.

What do you think?

Let me know what you think of this by replying on this article or if you have questions or suggestions, then please share them on GitHub or via our Support Center.

About a year ago, we assigned a small R&D team to rework and improve our customers’ experience with our documentation. Six months ago, at the time of the v18.1 launch, we first published a preview of this updated resource alongside the main documentation site. That was the beginning of our temporary run with dual documentation resources. Now that v18.2 is out, here’s a look at a report on our progress and an estimate on project completion.

Two Resources Are Still Available in v18.2

• https://documentation.devexpress.com
  This is the long-standing website, which is currently indexed by Google.
• https://docs.devexpress.com
  This is a link to the new documentation experience that we’re currently developing. This resource includes a version switch, mobile-friendly design, and non-.NET API Reference.

Differences between the Two Versions

Content differences between the two resources are minimal. Many of you will find it most practical to use our classic documentation and its superior search capabilities. (That's the resource indexed by Google. We don't allow Google to index both, as this will lead to conflicts between the two versions.)

The new site, however, has technical advantages and boasts .NET Core, JavaScript, iOS, and Android API Reference. Review the detailed list of differences below.

What's Been Done Since v18.1

Here's what the team has been working on during the last release cycle.

• Two systems now serve nearly identical content, so that you can pick one resource, and never have to switch back and forth.
• New documentation can be compiled into an offline Visual Studio help file.
• DevExtreme documentation's look and feel is now consistent with the new documentation resource.
• Considerable amount of testing and bug fixes.

New Plan: We'll Switch to a Single Resource by v19.1

The new resource is now fully functional and has been well-tested during the last release cycle. Only one major task remains before we flip the switch. We need to ensure a smooth website transition with minimal effect on search optimization - something we didn’t take into account when we first announced our transition plans. The work has begun, and we expect to return to single-source documentation by the v19.1 release.

I am pleased to announce that we have just released DevExpress Universal v18.2. As usual, Universal includes our suites for WinForms, the assorted varieties of ASP.NET, WPF, UWP, as well as DevExtreme. CodeRush Ultimate has also been updated.

For what’s new in this release, please go to this page and read all about the new features and enhancements across all the platforms and run-times. Also – a handy hint that I learned a couple of weeks ago – you can always navigate to devexpress.com/new and see what’s new in the latest version, whichever version number that happens to be.

As usual, we’ve listed the Resolved Issues introduced in this release. That page also enables you to review the changes we’ve made from any release to any other.

For every major release, no matter how hard we try and minimize the impact, some new features and enhancements are bound to cause a few breaking changes. You can read about the v18.2 breaking changes here.

Over the past year, via surveys, chatting with customers at conferences, reviewing comments and support tickets, we have concentrated hard on trying to find out what our customers want from our products going forward. Also, more than ever before, we’ve endeavored to publish relevant posts on what we are doing and how we aim to move forward. We now cover a lot of platforms with our components, and given the news from the open source community and from Microsoft (.NET Core 3, anyone?), I find we need valuable feedback from our customers more than ever.

I’d certainly like to thank everyone who provided feedback on our products throughout 2018, who used and tested the beta and provided information on the issues they found, and, of course, to all our customers who use our products every day. In my mind, it’s clear-cut: we would never be able to produce such robust and full-featured controls without all of this invaluable help. We are confident that the new controls, features, and enhancements in v18.2 will validate your trust in our products.

(PS: VCL Subscription customers: the v18.2 release is on its way…)

As you may recall, we announced XAF's new Web & Mobile development strategy based on ASP.NET Core and React in September: XAF - New SPA UI for Web & Mobile (v18.2).

Great news - you can now try our first XAF SPA UI demo.

To get started and see what is supported at this stage, please refer to the FAQ: New XAF HTML5/JavaScript SPA UI for Web & Mobile (CTP) KB Article. 

To discuss our new vision, roadmap and technical requirements more effectively with the XAF community, we have created a private discussion forum - exclusively for Universal customers. Feel free to leave comments to this post, email us at xafteam@devexpress.com or submit tickets using the Support Center if you are unable to join the discussion on our forum.

Adaptivity remains one of the most important features of a modern website. Which is why you'll appreciate the latest features that we've added to the ComboBox, DateEdit, and DropDownEdit controls:

• Scroll Picker
• Modal Drop Down

These features will enhance the usability on small screen (mobile) devices. Of course, both the DevExpress ASP.NET WebForms and MVC versions of the controls get these new features. Let's take a look.

Scroll Picker

We added a new mobile-friendly way to select dates with the DevExpress ASP.NET DateEdit control:

Enable

To enable this feature, set the DateEdit's PickerDisplayMode property to Auto, Calendar, or ScrollPicker. The default is Auto.

If the DateEdit is in modal mode, then the ScrollPicker is automatically selected. Otherwise, the standard Calendar is selected.

Demo - Scroll Picker - WebForms and MVC

Rest assured that the scroll picker mode works to help select the time section too.

Modal drop down

On smaller device screens, a popup can be difficult to see, so it's better to use a modal popup to gain the end user's attention.

Therefore, we've added a new modal drop-down mode to several of the ASP.NET Editors:

The animation above shows how much more effective it is to show the drop down as a modal popup in the middle of the screen for small screen devices. This allows end-users to easily select the necessary values from the controls with the drop-down.

This feature is available with the following controls:

• ComboBox
• DateEdit
• DropDownEdit

Settings

Set the SettingsAdaptivity.Mode property to OnWindowInnerWidth to enable this feature. Then, the control will switch to modal mode when the browser's width is less than the SwitchToModalAtWindowInnerWidth property value. Use the following settings to customize drop-down editors in adaptivity mode:

• DropDownEditBaseAdaptivitySettings (DateEdit and ComboBox)
• DropDownEditAdaptivitySettings (DropdownEdit)

Demo - Modal DropDowns - WebForms and MVC

More Editor Features

Check out some of the other great new features of the DevExpress ASP.NET Editors for ASP.NET WebForms and MVC in our latest release:

• ASP.NET, MVC, and Bootstrap - ComboBox, ListBox, and TokenBox - Database Server Mode (v18.2)
• ASP.NET and MVC Editors - Floating Action Button (v18.2)
• ASP.NET and MVC DateEdit & Calendar - Month-Year Picker (v18.2)

What are your thoughts on the DevExpress ASP.NET Editors' new adaptivity improvements? Drop me a line below, thanks!

If you've used our ASP.NET MVC GridView then you've likely experienced the integrated Filter Control. Unfortunately, due to various priorities, a stand-alone version was only available for the ASP.NET WebForms suite of controls.

Good news, the long-awaited DevExpress ASP.NET Filter Control is now available as a stand-alone ASP.NET MVC extension! The Filter Control allows your end-users to build filter criteria of any complexity and apply the filter to any data component or data model.

As a stand-alone control, you can use to filter other DevExpress MVC controls and also position the Filter Control anywhere on your MVC views.

Here's the stand-alone DevExpress MVC Filter Control with the DevExpress MVC GridView in action:

Helpful links:

• Demo
• Documentation

What are your thoughts on the new DevExpress ASP.NET MVC Stand-Alone Filter Control? Drop me a line below, thanks!

Great news for users of our Windows 10 UWP Control Suite: v18.2 includes a CTP version of our new Scheduler Control! As you would expect, the control displays calendar events or appointments, and it has interactive functionality to enable end users to manage this data.

Presentation

The Scheduler Control supports four different views. At design time you can specify which views are made available to end users at runtime. The views differ in the level of detail they display.

The Day view is the most detailed one, showing just one day at a time by default. The Work Week view shows days side by side, automatically including those days in a week that are set up as working days. The Week view includes all days in a calendar week, and the Month view shows all days in a month for long-term planning, using both columns and rows.

Views are customizable. For instance, the Day view can display several days side by side, and you can specify custom work days for the Work Week view. Multiple time rulers can show time for different time zones. All options are available in XAML so you don’t have to edit templates or write code.

Calendar events are visually represented by colored rectangles, and the Scheduler uses labels and status information to categorize items. End users can set labels and statuses in the Edit Form.

Labels are associated with colors, which are used as background colors for appointments. Strips on the sides of the appointment rectangles are painted with brushes that correspond to the statuses of the appointments.

Data Binding

The Scheduler is designed with MVVM in mind. You bind it to data by specifying mappings in XAML that associate appointment properties with data source fields. Here is an example of a XAML setup:

<Scheduler:SchedulerControl><Scheduler:Calendar AppointmentsSource="{Binding Appointments}"><Scheduler:Calendar.AppointmentMappings><Scheduler:AppointmentMappings
        Id="Id"
        AllDay="AllDay"
        Type="AppointmentType"
        Start="Start"
        End="End"
        Subject="Subject"
        Description="Description"
        Location="Location"
        RecurrenceRule="RecurrenceInfo"></Scheduler:AppointmentMappings></Scheduler:Calendar.AppointmentMappings></Scheduler:Calendar></Scheduler:SchedulerControl>

Recurrences

This release of the Scheduler Control includes complete support for recurring calendar events. End users can easily create recurring events, using just a few mouse clicks in the built-in Edit Form.

The Scheduler shows Visual indicators for recurring events automatically, and there is a special icon for occurrences that are parts of series but have been changed to no longer comply with the initial recurrence rule.

What’s Next?

The CTP release is available now, while we are working to polish the feature set. We are very interested in your thoughts. Do you have plans to use a Scheduler Control in a Windows 10 app? Is our functionality useful to you, or do you have important scenarios in mind that we don’t cover yet? Please let us know by leaving a comment below or by opening a ticket in our Support Center.

Here’s great news for web developers using our Reporting tools: you can now easily apply different color schemes to the reporting components, and even create your own!

In versions before v18.2, it was necessary to manually apply CSS styles to individual elements if you wanted to fulfill corporate design requirements for colors. We tried to help out with this work through support channels, but it was not an efficient way to solve a common problem. Enough about the past – the solution is here.

Default DevExtreme Color Schemes

The HTML5 Document Viewer and the Web Report Designer are based on DevExtreme widgets. You can now apply eight DevExtreme color schemes to the Reporting controls, with these six newly supported: Carmine, Soft Blue, Dark Moon, Dark Violet, Green Mist and Contrast. Each scheme contains nine colors:

Here are the different color schemes in the HTML5 Document Viewer:

In an ASP.NET WebForms application you can use the Color Scheme option in the Smart Tag menu to configure the scheme at design time:

In an ASP.NET MVC application, you can specify the color scheme as part of the style sheet registration:

@Html.DevExpress().GetStyleSheets(
  ASPxWebClientUIControl.ColorSchemeSoftBlue,
  new StyleSheet { ExtensionSuite = ExtensionSuite.Report }
)

In JavaScript-based applications (for instance using Angular), you need to include CSS files for the DevExtreme themes. The general approach is documented here, and you can find CSS files for the supported themes in the dist/css subfolder of your DevExtreme installation.

Please note that there is some extra work involved on our side to make DevExtreme themes compatible with the Reporting components. At this time we have not added support for the Material and Compact themes supplied by DevExtreme. Please let us know if these themes are important to you!

Custom Color Schemes

If the standard schemes don’t match your corporate identity or other requirements, you can take advantage of the new Reporting Color Scheme Customization feature. Here is a demo ready to try: Color Scheme Customization

Each color in the panel has a caption that describes its application. When you change the colors, you can see the effects instantly. Here’s an example of a preview with a few custom colors:

Near the drop-down box at the top where you select the standard schemes, you find three buttons. The first button is the most important one: Save Changes. It downloads a zip file with these three files:

1. devextreme.XXX.custom.css (XXX depends on the base scheme you customized) – This file contains CSS rules to style the DevExtreme widgets that are embedded in the HTML5 Document Viewer or the Web Report Designer. Note: if you already have a custom theme created using the DevExtreme Theme Builder, you do not need to use this file!
2. reporting.XXX.custom.css– These are the CSS rules to style those parts of the HTML5 Document Viewer and the Web Report Designer that are separate from the DevExtreme widgets.
3. dx.themebuilder.metadata.json– If you want to customize the DevExtreme widgets further (to be clear, these are the ones covered by devextreme.XXX.custom.css), you can import this file into Theme Builder.

If you don’t have a separate DevExtreme custom theme, you should include both CSS files from the zip file in your view HTML, like this (the names assume you customized the Green Mist scheme):

<link
  href="...YOURPATH.../devextreme.greenmist.custom.css"
  rel="stylesheet"
  type="text/css"
/><link
  href="...YOURPATH.../reporting.greenmist.custom.css"
  rel="stylesheet"
  type="text/css"
/>

If you have a separate DevExtreme custom theme, include it first and then the Reporting specific CSS file:

<link ... standard DevExtreme styles /><link ... custom DevExtreme theme CSS file /><link
  href="...YOURPATH.../reporting.greenmist.custom.css"
  rel="stylesheet"
  type="text/css"
/>

Using the other two buttons in the UI, you can also preview the changes you made to the base scheme, and reset all values to their defaults.

If You Need More Control

It is still possible to customize CSS classes directly, in case the options provided by the UI are not detailed enough for your use case. You can use the debugger built into your browser to find the names of classes applied to specific UI elements (usually by right-clicking and choosing Inspect Element or similar from the context menu). For example, you could set an independent background color for the right-hand tab button panel in the document viewer:

.dxd-side-panel-tabs-back-color {
  background: #197575;
}

In addition, our documentation includes details on many of the CSS classes used by the HTML 5 Document Viewer and the Web Report Designer (please follow the links).

Please Let Us Know Your Thoughts

As always, we are interested to hear what you think. Do you currently customize color schemes? If so, will the new features make your life easier in the future? If not, will you consider doing it now? Do you need us to support more color schemes out of the box?

We received several requests in 2018 to support QR Codes with images in the center. Some systems use these images to allow visual identification of a QR Code, and new European payment standards are being implemented in Switzerland that require QR Codes with center images to be included in invoices.

You can now use our BarCodeControl for WinForms and the XRBarCode for our Reporting system to render QR Codes with center images. Simply set the property QRCodeGenerator.Logo to your image of choice.

An image included in a QR Code reduces the degree of data redundancy in the code. In other words, the larger your image, the greater the chance that some scanners may not be able to read the QR Code correctly. Our algorithms assess this and display an error message if your image is considered too large:

Please note that there is no guarantee that QR Codes with center images will be recognized correctly by all scanners, so it is important for you to test your own scenarios.

Since the requirements of the Swiss invoicing standard were a special focus while we developed this feature, we made sure that Swiss invoices can be rendered correctly by following the published guidelines. We created a tutorial about creating Swiss QR Bills, and an online demo is also available.

(Note that updates to our documentation and the online demo will be published with our v18.2.4 minor release, to accommodate the final version of the Swiss standard published on November 15th 2018. The following screenshot already shows the updated design.)

Please let us know what you think. Does our implementation cover your requirements for center images in QR Codes? If you have any thoughts, or additional scenarios that need our consideration, please leave a comment below or open a Support Center ticket!

Based on user feedback, we’ve updated our benchmarks against EF 6 and EF Core:

    https://github.com/DevExpress/XpoNetCoreDemos/tree/master/ORMBenchmark

What's New in the benchmark?

• Updated NuGet package version:
  
  • Entity Framework 6.2.0 (EF 6);
    
  • Entity Framework Core 2.1.4 (EF Core);
    
  • eXpress Persistent Objects™ 18.2.3 (XPO).
    
• Graphs and their legends now display ORM versions.
• Each benchmark now also compares ORMs with direct SQL queries to show ORM overhead.
  

Run the updated benchmark tests or review our results here. Example: 

All benchmarks were executed using .NET 4.7.2, AnyCPU release builds (include warm-up), Windows 10 Enterprise x64, local Microsoft SQL Server 2016 Developer Edition, i7-7700 CPU @3.6GHz / 16GB RAM / SSD.

We also contributed to the Dapper.Tests.Performance benchmarks, so you can compare XPO with other micro and macro ORMs. See the results below:

It is an expected result that requests to macro-ORM take more time than requests to micro-ORM or direct SQL queries.

Interesting Support Center tickets

• We fixed an issue with the "The assembly does not have persistent classes" error in the ORM Data Model Designer (T680676);
  
• We described how to create a simple data layer to modify data using XPO and a stored procedure in the same transaction (T690250);
• We updated the K18356: How to use XPO data layer caching in XAF KB article;
• We still receive questions on Mono specifics from Xamarin developers, for instance, about using the System.Data.SqlClient and System.Drawing.Common assemblies in XPO apps (T661502 | T643780).
  

Your feedback counts!

Love XPO and want to help us promote it? Add the package through Nuget.org instead of DevExpress Nuget!

The powerful DevExpress ASP.NET Spreadsheet control is now available for our ASP.NET Bootstrap set of controls.

Preview

This control is available as a preview version in the v18.2 release. However, it supports nearly all major features, including the new Pivot Tables.

It's a preview version because we're working to improve the new Spreadsheet's performance, Touch UI and Mobile experience, and add several minor dialogs. In fact, we'll likely release these features in a future v18.2 minor release.

Let's take a look at some of the advantages of this new Spreadsheet control.

Appearance

Like other DevExpress ASP.NET Bootstrap controls, the new Spreadsheet control will work with nearly any Bootstrap theme. The control's appearance is set through the Bootstrap.css file so it will look great in all Bootstrap-based apps.

The new Spreadsheet control also supports the excellent new DevExpress Bootstrap themes:

Adaptive

The Spreadsheet also makes use of a new adaptive ribbon control that adjusts its items based on the screen size:

Features

Even though this is a preview version, the Spreadsheet control is packed with the following major features:

• Charting
• Formulas
• Comments
• Protection
• Images
• Printing
• Worksheet Display Area
• Freeze Panes
• Sorting and AutoFilter
• Data Validation
• Mail Merging
• Extensive UI options: dialogs, context menu, ribbon;
• Client-side and Server-side API

Feedback

Take a look at the online demo and documentation:

• Demo
• Documentation

Then test the new DevExpress Bootstrap Spreadsheet control in your Bootstrap web apps and give us your feedback.

We've added an improvement to the DevExpress ASP.NET Bootstrap controls that will boost the performance of page rendering. Let's take a look.

Deferred Client Object Initialization

When a control is first loaded, it also needs to load its client-side scripts. This can either be done by using:

• a script resource reference tag (eg <script id="dxis\_%id%" type="text/javascript" \>) or
• an inline JavaScript snippet (a startup script block)

In either scenario, the browser will pause as it loads and executes the script. In fact, if it's an external JavaScript file then you'll need a few more milliseconds to fetch the script from disk, cache, or remote server.

These types of script blocks affect your page rendering performance. So, we've added a couple of ways that help you deal with script loading and, subsequently, improve the overall performance.

Async

With the latest release, the script resource references are rendered as script blocks with the useful async attribute:

<script id="dxis\_%id%" type="text/javascript" async\>

The Async attribute allows the script resources to load asynchronously, therefore in parallel to page loading. This helps your page rendering times because the page will continue to display/render the content for the end-user without waiting for the scripts to finish loading.

Delayed

However, startup scripts will not use the Async attribute because they can be completely delayed until the end of the of the page. Therefore, startup scripts are treated as delayed initialize blocks and executed after all related script resources are loaded.

We've added the new allowClientObjectDeferredInitialization option for this specific purpose.

Performance

Let's take a look at how the new improvements perform in Google Chrome. For the tests below, we use the DevExpress ASP.NET Bootstrap Navigation Demo demo page.

First, let's take a look at the performance without the improvements:

allowClientObjectDeferredInitialization = false

Google Chrome Lighthouse audit (desktop, performance test, no throttling)

Google Chrome Network stats

Now, let's take a look at with the new improvements:

allowClientObjectDeferredInitialization = true

Google Chrome Lighthouse audit (desktop, performance test, no throttling)

Google Chrome Network stats

The network statistics tab shows that the page does not wait for script resource to finish loading (the blue vertical line indicates the DOMContentLoaded event raise timestamp, the red one - window load event raise timestamp).

Take a look at the specific lines with the option disabled and enabled:

allowClientObjectDeferredInitialization = false

allowClientObjectDeferredInitialization = true

The new script loading option speeds up page load times and therefore, allows your end-users to start interacting with the page sooner.

Async & Client-side API

Good news, our client-side static API is still available for developers even if the deferred client object initialization is enabled.

You can use global events to track the control's initialization:

<script type="text/javascript"\>
    function onButtonInit(s, e) {
            console.log(s.GetMainElement().id, "from control init");
        }</script><dx:BootstrapButtonID="BootstrapButton1"runat="server"AutoPostBack="false"Text="Button"ClientInstanceName="btn1"\><ClientSideEventsInit="onButtonInit"/\></dx:BootstrapButton\><scripttype="text/javascript"\>
    ASPxClientControl.GetControlCollection().ControlsInitialized.AddHandler(function(s, e) {
        console.log(btn1.GetMainElement().id, "from global init handler");
        });</script\>

The attached handler will be executed after all other scripts are loaded and executed, and the controls are initialized.

Warning

Please note, there may be JavaScript errors when accessing or modifying our controls from a script loaded afterward or in the jQuery $.ready() function.

To avoid this problem, please use the ASPxClientControlCollection.ControlsInitialized event to initialize all the required client-side scripts. This event is raised after all our controls are fully initialized and it's also the generally recommended way that you load your custom scripts. Take a look at the How to ensure that controls are initialized on the client side example to see how to use this event.

Old Style

By default, the new allowClientObjectDeferredInitialization will be set to true. However, if for some reason you'd prefer to use the old approach, then set allowClientObjectDeferredInitialization to false:

<configuration\>
  ...<devExpress\>
        ...<bootstrap allowClientObjectDeferredInitialization="false" /\>
        ...</devExpress\></configuration\>

Also, please make sure that the bootstrap section is defined in the web.config:

<configuration\><configSections\><sectionGroupname="devExpress"\>
        ...<sectionname="bootstrap" type="DevExpress.Web.Bootstrap.BootstrapConfigurationSection, DevExpress.Web.Bootstrap.v18.2, Version=18.2.3.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a" requirePermission="false"/\></sectionGroup\></configSections\>
  ...</configuration\>

What are your thoughts on the new performance improvements of the DevExpress ASP.NET Bootstrap controls? Drop me a line below.

The DevExpress Rich Text Editor and Word Processing File API now offers right-to-left text direction support. When we announced this feature in our v18.2 release cycle, we noted a few remaining issues with our implementation. In this short blog post, we’ll detail what we’ve addressed thus far and what we plan to implement in upcoming builds.

Fixed Issues

The following are known issues that will be fixed in v18.2.4:

• Improved table layout support (including correct column order, nested tables and cell borders appearance).
• Caret navigation and selection enhancements.
• Correct text direction during clipboard operations.
• Fixed problems encountered during keyboard input.

What's Next

Right now, we are working on scenarios related to undo/redo operations in bidirectional paragraphs. We will do our best to fix these issues in our v18.2.5 build.

Issues that Remain Unresolved

During research, we found several cases where numbers separated with punctuation marks are arranged incorrectly. Due to confusing standards, our behavior in such scenarios differs from that of Microsoft Word. This issue requires additional resources and information from customers. We do not expect to fix this issue in the near future.