In this post, we’ll outline some of the features we expect to ship in our next major release (v20.1). If you are active Universal or DXperience Subscribers, you are entitled to download our Early Access Preview (v20.1). If you are using DevExpress Charts, please take a moment to review this post and help us refine our implementation prior to the end of our current development cycle.

This post does not cover our JavaScript charting library. We’ll publish information on JavaScript related enhancements in a separate post.

WPF Charts - Customization Toolbar

The WPF Chart Toolbar allows you to quickly customize chart elements. End-users can print a chart, invoke the Chart Designer, change on-screen data range and much more. Toolbar content is customizable - you can add your own items (commands) and hide items you consider unnecessary.

Demo: MVVM Financial Charting

Documentation: Chart Ribbon and Toolbars

WPF Charts - Large Data Source Processing

v20.1 introduces a new data processing option to minimize memory footprint when processing extremely large datasets. This new mode is automatically enabled for charts with sorted numeric arguments and numeric values. You can also manually activate this mode using the XYSeries2D.AllowResample property.

Supported series types (EAP v20.1):

• LineSeries2D
• SplineSeries2D
• SplineAreaSeries2D
• SplineAreaStackedSeries2D
• AreaSeries2D
• AreaStepSeries2D
• AreaStepStackedSeries2D
• AreaStackedSeries2D
• BarStackedSeries2D

Demo: Large Data Source

Charts - New DateTime Axis Mode (WinForms, WPF, ASP.NET)

We enhanced the Date-Time scale by adding a SkipRangesWithoutPoints option. Enable it to automatically exclude all axis ranges without data points. This feature is especially useful for financial charting - you no longer need to manually define non-working date intervals.

Demo: Financial Charting

Charts - In-place Edit Mode for Annotations (WinForms, WPF)

You can now use the Chart Toolbar to add and remove annotations at runtime.

You can also enable the RuntimeEditing option for your existing annotations (allow end-users to edit text and replace images).

Demo: Annotations (WinForms) | Annotations (WPF)

Charts - New Series Label Display Mode (WinForms, WPF, ASP.NET)

Prior to v20.1, our Chart Control used the Series.LabelsVisibility property value to display or hide all Series labels simultaneously. We’ve added a new SeriesBase.LabelVisibilityMode setting so you can choose between various Series label display modes:

• First - Displays the first Series label based on the current X-Axis range.
• Last - Displays the last Series label based on the current X-Axis range.
• FirstAndLast - Both first and last Series labels are displayed based on the current X-Axis range.
• All - All series labels are visible (similar to LabelsVisibility = True)
• None - All series labels are hidden (similar to LabelsVisibility = False)

Note: LabelsVisibility property will continue to work (backward compatibility).

Demo: Large Series Number (WinForms) | Large Series Number (WPF)

WinForms Maps - Vector Item Enhancements

v20.1 includes a number of vector element enhancements:

• Added the MapItem.Tag property - Use it to store any objects related to the map item.
• Added SVG images for map pointer elements (pushpins, callouts, and custom elements). Use MapPointer.SvgImage and MapPointer.SvgImageSize properties to assign and customize SVG glyphs. In addition, you may specify MapPointer.SvgPaletteProvider to apply different colors based on item state (Selected, Highlighted or Normal)
• Added the MapPointer.Angle property - Use it to rotate map pointers.

Demo: Map Elements

Maps - New Vector File Format Support (WinForms, WPF)

The DevExpress Map Control supports data visualization for the following file formats:

• GPX files (Documentation: GpxFileDataAdapter | Demo: Gpx Data Adapter)
• GeoJSON files (Documentation: GeoJsonFileDataAdapter)
• KMZ files (Documentation: KmlFileDataAdapter)

Charts - Demo Enhancements (WinForms, WPF)

We have created new demos to cover two popular usage scenarios:

• Series Point Moving (WinForms) | Series Point Moving (WPF)

• Tornado Chart (WinForms) | Tornado Chart (WPF)

We are two months away from our next major update (v20.1). The purpose of this post is to share our progress and give XAF users the opportunity to test new functionality before we wrap up our current dev cycle.

XAF is part of the Universal Subscription. Active Universal subscribers are entitled to download and install this Early Access Preview. If you currently own an active DXperience Subscription, you can test the features described herein by logging onto the DevExpress Download Manager and installing this build in trial mode. Once you do, please take a moment to tell us whether these new features address your business needs. This will help us fine-tune our code before official launch. 

WinForms: Asynchronous Data Loading in List Views

GridListEditor can load its data asynchronously in XPO-based apps when DataAccessMode = Client. The UI continues responding to user actions as data is being retrieved - you can cancel the load operation by closing the View or navigate to another View (in MDI mode).  For more information, please refer to this KB article.

WinForms: Enhanced Filter Editor

XAF Grid, Tree and Pivot List Editors, Report and Dashboard designers now use an enhanced Filter Editor with a new display style, functions and skin support by default. For more information, please refer to this KB Article. 

Blazor: XAF's Demo Update & Security System Tutorials

XAF's recent Blazor demo update included new themes, editors and many other enhancements. For those unfamiliar with XAF, but looking for security related functionality, our new Blazor Server demo and tutorial should be of help. This demo is based on XAF's user authentication and group authorization APIs for .NET Core and .NET Framework apps.

This Early Access Preview adds a new Solution Wizard template to help you create and test XAF Blazor projects. For more information on XAF's Blazor UI strategy, please refer to the 2020 roadmap.

Security System for Entity Framework Core (CTP)

Our goal is to help DevExpress and non-DevExpress customers benefit from XAF's Security System and Entity Framework Core. We added a secured Object Space for EF Core 3.1+ and demonstrated its use for basic CRUD operations in a Console Application. For more information on XAF's user authentication and group authorization APIs for .NET Core and .NET Framework apps, please refer to this GitHub repo.

Coming Soon: Model Editor for .NET Core and .NET Standard Projects

Breaking Changes

Before you migrate and test existing projects, we ask that you read XAF's breaking changes document.

Your Feedback Matters!

Our next major update (v20.1) is a couple of months away. As such, we wanted to preview the features we expect to ship this Spring and invite all active DevExpress Universal subscribers to download our Early Access Preview (EAP). Your feedback will help us refine the features described below and allow us to ship the best possible royalty-free Dashboard platform in the marketplace.

Active Universal Subscribers: Download the EAP Today

Extending DevExpress Dashboard's Lifecycle API

Earlier this year, we published our 2020 Roadmap and detailed our primary objective: To evolve DevExpress Dashboard and give you (and your end-users) the ability to effectively customize the Dashboard throughout its entire lifecycle.

Our Early Access Preview includes the following lifecycle-related API enhancements:

1. Web Dashboard – Custom Properties for Dashboard Item, Custom Properties for Dashboard Data Item Containers (Chart Series, Grid Columns, Cards, Maps), Custom Properties For Dashboard
2. Web Dashboard – Options Panel customization (based on DevExtreme Form API)
3. Web Dashboard – event subscription with multiple handlers
4. Web Dashboard – new event itemWidgetOptionsPrepared (which can be used as a replacement for a pair of events itemWidgetCreated / itemWidgetCreated)
5. Web Dashboard – extended context for the existing events
6. .NET Dashboard Model – Custom Properties for Dashboard Items, Custom Properties for Dashboard Data Item Containers and Custom Properties for Dashboard
7. WinForms – simplified Ribbon Menu Customization based on Selected Dashboard Item Type (DashboardBarItemCategory and more).
8. WinForms Dashboard Designer – new events (DashboardOptionsChanged, DashboardCustomPropertyChanged, DashboardItemSelected)
9. WinForms Dashboard Designer & Viewer - extended context for event handlers. Extended context includes the Model of processed Dashboard Items (with Custom Properties)
10. WPF Dashboard Viewer - extended context for event handlers
11. Export Customization API.

Sample

I'll now demonstrate the value of our new API and illustrate how you can extend existing designer functionality with ease.

Let's assume you want to allow your end users to configure our Dashboard Chart Item. The goal is to change the drawing style used for the Chart's Line Series.

To begin, you'll need to set up your Web Dashboard Control. You'll need to declare and register the metadata for your custom property – the property that will store a user's selection in a custom LineTypeProperty XML element.

const lineTypeProperty = {
    ownerType: Model.SimpleSeries,
    propertyName: "LineTypeProperty",
    defaultValue: "solid",
    valueType: "string"
};
    
Model.registerCustomProperty(lineTypeProperty);

Next, you'll set up the Editors that are going to be displayed to end users:

_onCustomizeSections = function(args) {
…
    args.addSection({
        title: "Line Options (Custom)",
        items: [
            {
                dataField: lineTypeProperty.propertyName,
                editorType: "dxSelectBox",
                label: {
                    text: "Line style"
                },
                editorOptions: {
                    items: [
                        { value: "dash", displayValue: "Dashes" },
                        { value: "dot", displayValue: "Dots" },
                        { value: "longDash", displayValue: "Long Dashes" },
                        { value: "solid", displayValue: "Solid Line" },
                        { value: "dashdot", displayValue: "Dash-Dot" }
                    ]
…
                }
            }
        ]
});

You then subscribe to the new itemWidgetOptionsPrepared event to customize the widget based on user selection.

viewerApiExtension.on("itemWidgetOptionsPrepared", _onItemWidgetOptionsPrepared);
…
_onItemWidgetOptionsPrepared = function(args) {
    if (args.dashboardItem instanceof Model.ChartItem) {
        var seriesOptionArray = args.options["series"] || [];
        seriesOptionArray.forEach(function(seriesOption) {
            if (seriesOption.type === "line") {
                var series = args.chartContext.getDashboardChartSeries(seriesOption);
                if (series) {
                    var lineType = series.customProperties.getValue(lineTypeProperty.propertyName);
                    seriesOption.dashStyle = lineType;
                }
            }
        });
    }
};

That's all you'll need for the Web portion....

If targeting desktops, you'll want to customize your WinForms Designer & Viewer to read and write the same metadata from the same XML Dashboard file.

If you want to add similar settings to WinForms Dashboard Designer, use the simplified Ribbon API:

var page = ribbon.GetDashboardRibbonPage(DashboardBarItemCategory.ChartTools, DashboardRibbonPage.Design);
RibbonPageGroup group = page.GetGroupByName("Custom Properties");
if(group == null) {
    group = new RibbonPageGroup("Custom Properties") { Name = "Custom Properties" };
    page.Groups.Add(group);
}

Next, you'll need to create a custom XtraForm and display it to your users:

For the last step, you'll need to subscribe to the DashboardItemControlUpdated event and use its extended context to read custom properties and configure your Chart accordingly.

void Designer_DashboardItemControlUpdated(object sender, DashboardItemControlEventArgs e) {
    if(e.ChartControl != null) {
        var chartItem = designer.Dashboard.Items[e.DashboardItemName] as ChartDashboardItem;
        var context = e.ChartContext;            

        var dashboardSeries = chartItem.GetRelatedSeries("LineTypeProperty");
        foreach(var series in dashboardSeries) {
            SeriesLineStyle seriesLineStyle = SeriesLineStyle.GetStyle(series.CustomProperties.GetValue("LineTypeProperty"));
            if(seriesLineStyle != null) {
                Series chartSeries = context.GetChartSeries(series).FirstOrDefault(x => x.Name.Contains(seriesLineStyle.SeriesName));
                if(chartSeries != null) {
                    LineSeriesView view = chartSeries.View as LineSeriesView;
                    if(view != null) {
                        view.LineStyle.DashStyle = seriesLineStyle.Style;
                    }
                }
            }
        }
    }
}

As you can see below, your dashboard will utilize the same data within the WinForms Designer & Viewer.

This is just a simple example. You can apply the same customization within the WPF Dashboard Viewer control. You can also utilize it during export operations via our new Export Customization API. We will share additional examples in the ooming weeks and make them available in our GitHub Examples repo. Please stay tuned!

Note: This demo is available for both the Web and WinForms version of DevExpress Dashboard (EAP installation is required to open the link).

Filter to the Measure

You can now set up a Filter expression for a single Measure bound to your Dashboard Item (i.e. you can filter a single Measure to be calculated only for a specific time period or for a single Product Category, etc).

This feature was not planned, but we needed it internally for the better Parallel Period support. We decided to publish it because it addresses use cases that you've shared with us in the past.

Tab Item – Performance Optimization Mode

We added new options for WinForms and WPF platforms so you can configure how Dashboard Items within Inactive Tabs are loaded during the first data load – always or on demand. Please note the documented restrictions on the Dashboard Items load order. We must always load data for Master Filter Item, even when it's placed on the Inactive Tab.

Export Customization API

v20.1 includes our new Export Customization API. Now, you can maintain maximum customization of XRControls. For our upcoming release, we chose to extend support for our most popular UI controls - Charts and Gauges. One of the entry points to the new API is the GetPrintableControl method. We updated the CustomerSupport demo to demonstrate this new approach. You can find it in the Dashboard Demo Center.

Viewer.CustomExport += OnCustomExport;
...

void OnCustomExport(object sender, CustomExportEventArgs e) {
    ChartDashboardItem chartItem = Dashboard.Items[e.ItemComponentName] as ChartDashboardItem;
    if(chartItem != null) {
        XRChart chartControl = (XRChart)e.GetPrintableControl(e.ItemComponentName);
        foreach(Series chartSeries in chartControl.Series) {
            LineSeriesView view = chartSeries.View as LineSeriesView;
            if(view != null)
                view.LineStyle.DashStyle = DashStyle.Dot;
        }
    }
}

JSON Data Source - Parameters Support

You can now bind your Dashboard Parameters to JSON Path Parameters and Query Parameters (for both the WinForms and Web version of DevExpress Dashboard).

Visual Warning in Expression Editor

We added a visual indicator – a warning icon – to our WinForms Expression Editor. In our EAP release, this indicator warns users that wish to execute [int] / [int] division – an action that can produce unexpected results. Some users may expect Excel-like behavior [int] / [int] = [double] (i.e. 10 / 4 = 2.5) in this scenario. As you may know, we historically stick to the .NET C# [int] / [int] = [int] approach in this situation (i.e. 10 / 4 = 2). This difference can obviously lead to data loss and as such, we decided to add a warning when [int] to [int] division is created in an Expression.

Comments in Calculated Fields

In case you missed it – with v19.2.5 and higher, you and your users can add Comments to your Calculated Fields. This feature should help improve readability for complex expressions (together with Line Breaks and Spaces in Calculated Fields which was introduced in our v19.2.3 release).

Rich Text Editor for TextBox Item in Web

We recently mentioned the availability of Rich Text Editor for TextBox Dashboard Items (available as a CTP in our v19.2.6 release). Rich Text Editor will be officially released in our v20.1 release cycle.

In the Works

Card Item Conditional Formatting

While we decided to not include this feature in the Early Access Preview release, the progress of this feature is moving along nicely.

We have already created and mostly finalized the Model for CardConditional Formatting Rules. Our data engine is can already calculate the required rules and pass results to WinForms, Web and WPF user interfaces. The only missing piece is the Designer portion of Web / WinForms Dashboard Designers.

As we promised, you will be able to create conditional formatting based on the Measure (Actual or Target Values), Series Dimension AND you will be able to set up a highlighting rule based on the delta between Actual / Target.

You will be able use Formatting Styles similar to those used for Grid / Pivot Grid conditional formatting. You will be able to change selected Card element Font, add an Icon or apply the background color to the entire Card.

We expect this feature to be available in our v20.1 Beta (v20.1.2) in early April.

Parallel Periods

We plan to incorporate additional enhancements for parallel periods in our v20.1 release.

We are working on this feature and already shared intermediate results with you (see Filter to the Measure above). We prepared a demo that shows how you can utilize Filter to the Measure to compare data between Parallel Periods (in Charts, Grids, in Delta columns). The demo is available online and in our WinForms Demo Center (Early Access Preview should be installed).

We are presently reconsidering UI/UX options for this feature.

Year-Week Group Interval

This feature is still on target for our v20.1 release.

Your Feedback Matters

As always, we welcome your feedback. Please post your comments below or create a new support ticket if you've beta tested our Early Access Preview.

This post includes a list of new products/features we expect to ship for Xamarin.Forms in our v20.1 release cycle.

As always, should you have any questions about these new products/features, please post your comments below. We’ll be happy to follow up.

If you own an active Universal Subscription, point your browser to the DevExpress Download Manager and download our v20.1 Early Access Preview today. Feedback is welcome and appreciated.

Xamarin.Forms Charts – Range Bar Series

v20.1 will include a new Xamarin.Forms Range Bar series – designed to display value ranges grouped by Series point arguments (see the following article for additional information).

Xamarin.Forms Charts – Axis Enhancements (Logarithmic scale, New Axis Layout)

Our Chart control’s Axis element now supports Logarithmic scale for numeric data. In addition, v20.1 includes new Axis layout modes (Absolute and Relative) so you can display axes at custom positions within the chart’s diagram.

Xamarin.Forms Data Grid - Row Drag and Drop

v20.1 will ship with Row Drag and Drop support. Use the AllowDragDropRows property to enable this behavior within your Xamarin app. For additional information, please refer to the following article.

New Xamarin.Forms Data Editors

V20.1 will ship with the following new Data Editors:

• TextEdit
• PasswordEdit
• MultilineEdit (Android only)

All text editors follow material guidelines and support data validation, interactive start/end icons and themes (Light and Dark).

Our Xamarin.Forms text editor will ship with input mask support and display format features.

Your Feedback Counts

As I mentioned earlier, your feedback matters. If you own an active Universal Subscription, please download our Early Access Preview and share your experiences with us.

Protect Sensitive Data - Using SQL Server and Always Encrypted 

XPO v20.1 supports Always Encrypted for SQL Server 2016+. You can now read, update, sort and filter encrypted column data (the last two operations depend on encryption mode).  

If you are not yet familiar with this SQL Server feature, let me quote the official documentation: 

Always Encrypted is a feature designed to protect sensitive data, such as credit card numbers or national identification numbers (for example, U.S. social security numbers), stored in Azure SQL Database or SQL Server databases. Always Encrypted allows clients to encrypt sensitive data inside client applications and never reveal the encryption keys to the Database Engine (SQL Database or SQL Server).

For more information, refer to Always Encrypted and Using Always Encrypted with the Microsoft .NET Data Provider for SQL Server.

Please Help Us Test Major Changes to the XPO Core against All DB Providers 

XPO Officially Supports Microsoft.Data.SqlClient

Microsoft recommends the new Microsoft.Data.SqlClient driver instead of System.Data.SqlClient for new .NET Framework and .NET Core projects. Going forward, Microsoft will also only support new SQL Server features in Microsoft.Data.SqlClient. 

We tested XPO with this new driver, updated the Database Systems Supported by XPO article and some public APIs. For instance, the CreateSqlDependencyCacheRoot methods now accept an IDbConnection object as a parameter.

Breaking Changes

Please refer to the following article: The DevExpress.Data, DevExpress.Xpo and other cross-platform assemblies for .NET Core 3 (WinForms & WPF), .NET Standard, .NET Framework apps have been split or removed. While these changes will not affect the majority of XPO users, they help simplify common development tasks like How to Share Class Libraries with the DevExpress Data or XPO Dependencies for Different Target Frameworks.

Coming Soon: Database Schema Migrations

Our final v20.1 release (in 1-2 months) will also allow users to incrementally update database schema and preserve existing data after changes are made to XPO’s data model (AS4684). Our goal is to make this process better than that found in EF Core Migrations. For starters, we will generate diffs between the latest data model and existing database schema so that you can apply the SQL script manually. For v20.2, we are considering to update schema automatically via a special command in the ORM Data Model Designer or some CLI. If you have any questions or suggestions about implementation, feel free to email us at XpoTeam@devexpress.com - we will be happy to follow up.

We thank you for your ongoing business and for choosing our ASP.NET WebForms and MVC controls. In this post, I’ll describe many of the enhancements we will include in our first major release of 2020. As always, we would love to hear your feedback in the comments below. 

A quick reminder: If you are an active  Universal or DXperience subscriber and want to test upcoming v20.1 features before our official release, you can download the Early Access Preview build via the DevExpress Download Manager. Please let us know how well the new functionality described herein addresses your business requirements. Your feedback will help us fine-tune our implementation prior to official release.

ASP.NET & MVC Diagram  

Template-Enabled Custom Shapes 

With this release, you can introduce custom shape content using an SVG element. The SVG element can contain images, text, and hyperlinks  

Handle the CustomShapeCreateTemplate event to specify a template for your custom shape.  

See the documentation for more information. 

ASP.NET & MVC OrgChart Shapes

Our updated ASP.NET Diagram control includes new OrgCharts shapes. You can bind the control to a data source to display custom images in shapes. The ImageUrl property specifies the image data field's name. Users can select a shape image via UI elements.

See OrgChart documentation for more information. 

New Client-Side API 

The release version of our ASP.NET Diagram control includes new client-side API to handle user actions. You can use the ItemClick, ItemDlbClick, and SelectionChanged events to handle user interactions within the Diagram. 

New ASP.NET Diagram Shape and Connector Lines

We have added dash and dot line types that can be used for shapes and connectors.

Context Toolbox 

The DevExpress ASP.NET Diagram displays a context toolbox when you draw a connector from a shape and release it without connecting it to another shape. The toolbox allows you to create a shape at the end of the connector. This makes diagram generation faster and easier. Use the SettingsContextToolbox property to customize the context toolbox content. 

Themes Support 

The release version of our ASP.NET Diagram will support all ASP.NET DevExpress themes.  

Support for Mobile Devices 

Our Diagram’s layout and UI is adapted for use on mobile devices. The new interface helps users work with a diagram on devices with a small touch screen more effectively. 

Enhanced Drawing Performance

We optimized our Diagram’s inner shape drawing algorithms to improve performance when using a large number of shapes.

Changes in API

The release version of our Web Forms and MVC Diagram will include a new public API. If you evaluate our Diagram CTP, I highly recommend you check the upcoming API changes.

ASP.NET & MVC Gantt Control

New Gantt Column Types

Our WebForms and MVC Gantt control now supports different column types within the task list area. This functionality is useful if you need to display different data in the task list and give your users advanced editing capabilities.

To bind a column to your data source, assign a corresponding data field name to the FieldName property. See the Column Editor article for details. 

Gantt Strip Lines

This feature allows you to highlight specific dates or intervals in the chart area. Our Gantt supports an automatically updated current time marker, single strip lines, and intervals. You can enable them in any combination.  

Refer to Highlight Current Time, Create a Single Strip Line and Highlight a Time Interval sections in our online help file to learn more about time markers. .

You can assign custom CSS classes to any time marker using the SettingsStripLine.CurrentTimeCssClass and StripLine.CssClass properties.

Gantt Dependency Validation

We added Dependency Validation to our ASP.NET Gantt control. Once a user modifies data, the Gantt automatically updates tasks to maintain valid dependencies. If Gantt cannot resolve the conflict, the control displays a dialog with two options: cancel the action or delete the dependency between the tasks.

By default, our ASP.NET Gantt control does not validate relationships between tasks. To enable this functionality set the GanttValidationSettings.Enabled operty to True.  

Gantt Toolbar

The new built-in toolbar comes with a set of standard items. You can also create custom items to address desired functionality. To display the toolbar, enable the GanttToolbarSettings.Visible property. All toolbar items are available in the GanttToolbarSettings.Items collection.

The default items allow you to implement basic out-of-the-box operations: add/remove tasks, undo/redo changes, zoom in/out, expand/collapse all tasks.

To create a custom item, add a new GanttToolbarItemto the Itemscollection. Use the client-side CustomCommandExecuted event to process a custom item click. 

Items can have a hierarchical structure. All items allow you to customize icons and text used for Text and Image properties.

Changes in API

The release version of our Web Forms and MVC Gantt will include a new public API. If you evaluate our Gantt CTP, I highly recommend you check the upcoming API changes.

ASP.NET & MVC Rich Text Editor (Word Processing)

Client-Side WYSIWYG Export  

Document layout may look different in browsers and in an exported or printed document due to the unique nature of each browser. This difference is an issue for many applications. Our upcoming (v20.1) ASP.NET Rich Text Editor can export a document to PDF on the client side so that PDF layout mirrors the layout within a browser. 

Font Management API

We improved the Rich Text Edit’s font management API. You can now specify font information for the ribbon and all dialogs in a single location in code.

ASP.NET & MVC Charts

New DateTime Axis Mode

We enhanced the Date-Time scale by adding a SkipRangesWithoutPoints option. Enable it to automatically exclude all axis ranges without data points. This feature is especially useful for financial charting - you no longer need to manually define non-working date intervals.

New Series Label Display Mode

Prior to v20.1, our Chart Control used the Series.LabelsVisibility property value to display or hide all Series labels simultaneously. We’ve added a new SeriesBase.LabelVisibilityMode setting so you can choose between various Series label display modes:

• First - Displays the first Series label based on the current X-Axis range.
• Last - Displays the last Series label based on the current X-Axis range.
• FirstAndLast - Both first and last Series labels are displayed based on the current X-Axis range.
• All - All series labels are visible (similar to LabelsVisibility = True)
• None - All series labels are hidden (similar to LabelsVisibility = False)

Note: LabelsVisibility property will continue to work (backward compatibility).

WebForms for Bootstrap

In our upcoming release, we will ship enhancements for our ASP.NET WebForms controls for Bootstrap.

Bootstrap GridView - Edit Form Layout

Our upcoming release will include an Edit Form Layout for the Bootstrap GridView. This layout allows you to arrange default edit form editors in an embedded Form Layout.

If you used Edit Form Layout in our 'classic' WebForms GridView, this feature will be familiar to you. The same API was used in our Bootstrap Grid.  

Bootstrap Accordion - Group Render Customization  

Our Bootstrap Accordion gives you the ability to customize a group’s appearance. We added new customization API to customize Accordion groups:

Your Feedback Matters

We’ve compiled a short list of interesting VCL-related support tickets we answered in February. Hopefully, you’ll find them of value and can integrate our suggestions in your next Delphi project.

If you’d like to share a VCL-related support ticket with the DevExpress developer community, please feel free to a post a link below.

ExpressQuantumGrid Suite

• How to modify text of the Chart View's abscissa axis without affecting hint text
• How to conditionally avoid storing column properties
• How to synchronize the column order of two views

ExpressPivotGrid Suite

• How to customize group captions

ExpressQuantumTreeList Suite

• What's the difference between the VisibleCount and AbsoluteVisibleCount properties

ExpressBars Suite

• How to create a toolbar application menu and populate it at runtime
• How to merge ribbons when using tabbed MDI layouts

ExpressLayout Control

• How to modify margins/padding
• How to display different hints for different tabs within a tabbed layout group

ExpressSpreadSheet

• How to visualize the progress of formula calculations

ExpressScheduler Suite

• How to store and restore recurring holidays

ExpressRichEdit Control

• How to hide all inner borders and show borders for required rows/cells in a table programmatically
• How to insert content at the start of the document

ExpressEditors Library

• How to access the multiline editor in the dropdown window of the TcxBlobEdit control

Your Feedback Counts

As always, we welcome your comments and feedback. If you’ve come across a useful Support Center ticket, feel free to share it with the DevExpress developer community here.

General

App State

Client vs Server

SignalR / Hosting

XAF, XPO & Databases

Authentication

DevExtreme & Other Frameworks

Blazor Roadshow

Because of the outbreaks of COVID-19 everywhere and the cancellation of several major public events across the US, we do not think it wise to continue Carl Franklin’s Blazor Roadshow at this present time. Hence we are postponing all remaining stops and will reschedule them at a later time. We apologize to everyone in those remaining nine cities, but are of the opinion that discretion and good sense is of the utmost importance in this case.

Stay tuned: once the situation stabilizes and we have more information, we shall arrange a new timetable for the Blazor Roadshow. Meanwhile, do please take care of yourselves and your families.

Last week, we where at the BASTA Spring 2020 conference in Frankfurt Germany.

There was a lot of interest in Blazor and we where able to show our native Blazor controls at the booth besides our other products like DevExtreme, WPF, Winforms and ASP.NET WebForms, MVC and Core.

I had a well attended session on our opensource UI Webtesting tool - TestCafé with lots of interest at the booth afterwards. We did daily raffles and on the last day we raffled off our 'Funky Bull' BlueTooth speaker.

Her are some pictures to get an impression:

DevExtreme DataGrid/TreeList

Remote Validation Support

Please, refer to the discussion page for more information.

New Export to Excel API (RTM)

CustomizeCell Callback

Column Bands Export Support

Cell Text Alignment, Wrapping and Font Settings

DataGrid’s Column Format Support

DevExpress.excelExporter.exportDataGrid({
  customizeCell: function(options) {
    const { gridCell, excelCell } = options;
    if(gridCell.rowType === ‘data’) {
      if(gridCell.column.dataField === 'Phone') {
        excelCell.numFmt = '[<=9999999]###-####;(###) ###-####';
      }
    }

Cell Image Export Support

Integrated Excel Filtering Support

DevExpress.excelExporter.exportDataGrid({
  autoFilterEnabled: true,
  ...
})

Integrated Export Status Panel

DevExteme Scheduler

Hourly Repeating Events

Adaptivity Enhancements

API Enhancements

DevExtreme Diagram

Template-Enabled Custom Shapes 

With this release, you can introduce custom shape content using an SVG element. The SVG element can contain images, text, and hyperlinks  

The customShapeTemplate option defines a common template for all shapes in the widget. The template option defines a template for an individual shape.

API Enhancements

The release version of our JavaScript Diagram control includes new client-side API to handle user actions. You can use the onItemClick, onItemDblClick, and onSelectionChanged events to handle user interactions within the Diagram.  

New Shape and Connector Lines

We have added dash and dot line types that can be used for shapes and connectors. 

Context Toolbox 

The DevExpress ASP.NET Core Diagram displays a context toolbox when you draw a connector from a shape and release it without connecting it to another shape. The toolbox allows you to create a shape at the end of the connector. This makes diagram generation faster and easier. Use the contextToolbox option to customize the context toolbox content. 

Support for Mobile Devices 

Our Diagram’s layout and UI is adapted for use on mobile devices. The new interface helps users work with a diagram on devices with a small touch screen more effectively. 

Enhanced Drawing Performance

We optimized our Diagram’s inner shape drawing algorithms to improve performance when using a large number of shapes.

DevExtreme File Manager

Upload and Download for In-memory JSON data

DevExtreme FileManager gives you the ability to upload and download files into in-memory storage without requests to your server. To enable this feature:

1) Register the JSZip library in your project. 

2) Connect the FileManager to the ObjectFileSystemProvider.

3) Enable “upload” and “download” permissions within the FileManager.

File Manager API enhancements

We reworked the current FileManager API to make it clear and consistent.

File System Providers modularity 

We extracted our file system providers to separate modules. You do not need to have the entire FileManager code on a page if you want to use a stand-alone file system provider. Import the corresponding “devextreme/file_management” module and use the provider without the FileManager. Note that extracted file system providers have new names.

DevExtreme TreeView

Selection API Enhancements

HTML/Markdown Editor

Adaptivity Enhancements

Data Visualization

Polar Chart Annotations

Custom Position of Chart Axes

Native React Components

Native React Grid - Export to Excel

Native React Scheduler - Resources & Grouping

This post includes a list of new products/features we expect to include in our ASP.NET Core Early Access Preview build (v20.1). As always, should you have any questions about these new products/features, please post your comments below. We’ll be happy to follow up.

A quick reminder: If you are an active  Universal or DXperience subscriber and want to test upcoming v20.1 features before our official release, you can download the Early Access Preview build via the DevExpress Download Manager. Please let us know how well the new functionality described herein addresses your business requirements. Your feedback will help us fine-tune our implementation prior to official release.

New DevExtreme-based ASP.NET Core Project Wizard

Single entry

We combined multiple ASP.NET Core project templates into a single new item which is easier to find within the template list:

Any Combination 

• Two .NET Core LTS versions - 2.1 and 3.1. Note that 3.1 is only available in Visual Studio 2019.
• Razor Pages or MVC Views
• Bootstrap or Material application layout

Should you so wish, you can also use the DevExpress Template Gallery:  

ASP.NET Core DataGrid/TreeList

Remote Validation Support

New Export to Excel API (RTM)

CustomizeCell Callback

Column Bands Export Support

Cell Text Alignment, Wrapping and Font Settings

DataGrid’s Column Format Support

DevExpress.excelExporter.exportDataGrid({
  customizeCell: function(options) {
    const { gridCell, excelCell } = options;
    if(gridCell.rowType === ‘data’) {
      if(gridCell.column.dataField === 'Phone') {
        excelCell.numFmt = '[<=9999999]###-####;(###) ###-####';
      }
    }

Cell Image Export Support

Integrated Excel Filtering Support

DevExpress.excelExporter.exportDataGrid({
  autoFilterEnabled: true,
  ...
})

Integrated Export Status Panel

ASP.NET Core Scheduler

Hourly Repeating Events

Adaptivity Enhancements

API Enhancements

ASP.NET Core Diagram  

Template-Enabled Custom Shapes 

With this release, you can introduce custom shape content using an SVG element. The SVG element can contain images, text, and hyperlinks  

The customShapeTemplate option defines a common template for all shapes in the control. The template option defines a template for an individual shape.

New Client-Side API 

The release version of our ASP.NET Core Diagram control includes new client-side API to handle user actions. You can use the ItemClick, ItemDlbClick, and SelectionChanged events to handle user interactions within the Diagram. 

New ASP.NET Core Diagram Shape and Connector Lines

We have added dash and dot line types that can be used for shapes and connectors.

Context Toolbox 

The DevExpress ASP.NET Core Diagram displays a context toolbox when you draw a connector from a shape and release it without connecting it to another shape. The toolbox allows you to create a shape at the end of the connector. This makes diagram generation faster and easier. Use the contextToolbox option to customize the context toolbox content. 

Support for Mobile Devices 

Our Diagram’s layout and UI is adapted for use on mobile devices. The new interface helps users work with a diagram on devices with a small touch screen more effectively. 

Enhanced Drawing Performance

We optimized our Diagram’s inner shape drawing algorithms to improve performance when using a large number of shapes.

Changes in API

The release version of our ASP.NET Core Diagram will include a new public API. If you evaluate our Diagram CTP, I highly recommend you check the upcoming API changes.

ASP.NET Core Rich Text Editor (Word Processing)

Client-Side WYSIWYG Export  

Document layout may look different in browsers and in an exported or printed document due to the unique nature of each browser. This difference is an issue for many applications. Our upcoming (v20.1) ASP.NET Core Rich Text Editor can export a document to PDF on the client side so that PDF layout mirrors the layout within a browser. 

Font Management API

We improved the Rich Text Edit’s font management API. You can now specify font information for the ribbon and all dialogs in a single location in code.

ASP.NET Core File Manager

Upload and Download for In-memory JSON data

ASP.NET Core FileManager gives you the ability to upload and download files into in-memory storage without requests to your server. To enable this feature:

1) Register the JSZip library in your project. 

2) Connect the FileManager to the ObjectFileSystemProvider.

3) Enable “upload” and “download” permissions within the FileManager.

File Manager API enhancements

We reworked the current FileManager API to make it clear and consistent.

File System Providers modularity 

We extracted our file system providers to separate modules. You do not need to have the entire FileManager code on a page if you want to use a stand-alone file system provider. Install the corresponding “devextreme/file_management/” module and use the provider without the FileManager. Note that extracted file system providers have new names.

Server-side API enhancements

We implemented a more flexible and transparent API to handle file operations on the server side. You can now enable specific file system functionality for your application using new interfaces:

• IFileSystemItemLoader – to view files and folders;
• IFileSystemItemEditor – to enable editing operations (create directory, copy, delete, move);
• IFileUploader – to support file upload to your file system;
• IFileContentProvider – to get file binary data.

Please refer to the list of server-side API changes and sample project with this new API for more information.

ASP.NET Core TreeView

Selection API Enhancements

HTML/Markdown Editor

Adaptivity Enhancements

Data Visualization

Polar Chart Annotations

Custom Position of Chart Axes

Your Feedback Matters

Before I discuss community news, I want to send my best wishes to everyone. Here's hoping you are all safe and doing well.

New XAF Community Modules

1. The eXpand Framework, managed by Apostolis Bekiaris, continues to release new platform-agnostic packages for XAF: http://xaf.expandframework.com/. Unlike the former monolithic version of eXpand, these are low-dependency packages. They also work with previous XAF versions, and include unit tests that run on Azure, wiki and demos. I want to promote the new NuGet package that contains a standalone version of XAF's Model Editor, designed to integrate with Visual Studio, Rider, Explorer - Xpand.XAF.ModelEditor.
2. A new version of XAFARI that works with v19.2.6 is available. Galaktika Soft has been providing paid reusable XAF modules with documentation and support services for more than 6 years.
3. In case you missed it, LlamaChant published a new free module: https://www.llamachant.com/single-documents/xaf-sample-security-preview-module/. I also want to remind you that Dave Hesketh and his colleagues have been providing XAF training, consulting and custom development services for a number of years. If you are not familiar with Dave and want to know about the tools he uses, his opinion on Blazor and also his advice for XAF beginners, visit http://xafersweekly.com/issues/17#start - this news feed is run by Jose Columbie, another XAF customer and consultant. To learn more about Dave's For a full list of third-parties providing similar services, visit this page.
4. Manuel Grundner, a DevExpress MVP, worked on a new project and shared some of his results in his blog: Install a blazor app as globaltool and service. Earlier Manuel also created an XAF chat at https://gitter.im/XAF-Community/community. It's not very active lately, but I wanted to bring attention to it should XAFers want to discuss development questions.
5. Christian Angermeier published a module on GitHub (MS-PL License): GDS.ExpressApp.UserFilter. This XAF module works for both Windows and Web platforms and helps create user-specific filters for ListViews (using the navigation and main menus).

Have you published XAF modules on GitHub or NuGet.org? Please let the XAF community know by posting a comment below. Thanks!

Welcome Joche Ojeda, a New DevExpress MVP

You might know Joche from his promotion efforts in the Spanish community - his XAF Facebook developer group (https://www.facebook.com/xafes/) has almost 400 members. Joche also does XAF/XPO consulting and custom development for companies in North and Latin America. He also published many free XAF/XPO/Xamarin modules, tutorials and training videos for the community. For instance, if you are new to XAF, you may want to check his webinar video:

My experience with the DevExpress Frameworks has grown as they have developed as products. I have been using XAF and XPO from the day they were released, which means I began with XPO way back in 2005. Before becoming an independent consultant, one of the last tasks I had as a lead developer in the company I was working for, was to evaluate frameworks to create a unified ERP. I was already using the DevExpress products and when XAF was released, I fell in love! I also continue to be a big XPO advocate and use it exclusively in all my projects, from ASP.Net MVC, ASP.Net Core to Xamarin and lately UNO platform.

For the full list of Joche's contributions and also full bio, please visit his web sites: https://www.jocheojeda.com | https://www.bitframeworks.com | https://www.xafers.training. For more XAF getting started tutorials and videos, refer to this DevExpress documentation page. 

This is the final post in our "Mobile Stock Market App" blog series. If you are new to this series, feel free to review our previous posts to learn more about our Mobile Stock Market app and how it was built using our Xamarin control library.

1. Part 1 - Initial design
2. Part 2 - Navigation within the app
3. Part 3 - Presentation of data collections

In this final post, we’ll show you how we used our Xamarin Forms Charting library to create intuitive stock price analysis views within the mobile app.

Portfolio Share Chart

The Stock Market app’s Portfolio Page uses our Xamarin Pie Chart View to display stock allocations within a user’s hypothetical stock portfolio:

View Markup

<dxc:PieChartView  
    SelectionMode="Single"  
    SelectionBehavior="Hatch"> 
    <dxc:PieChartView.Hint> 
        <dxc:PieHint ShowMode="OnTap"/> 
    </dxc:PieChartView.Hint> 
    <dxc:PieChartView.Series> 
        <dxc:DonutSeries> 
            <dxc:DonutSeries.HintOptions> 
                <dxc:PieSeriesHintOptions PointTextPattern="{}{L}: {VP}%"/> 
            </dxc:DonutSeries.HintOptions> 
            <dxc:DonutSeries.Data> 
                <dxc:PieSeriesDataAdapter  
                    DataSource="{Binding ChartViewModel.Data}" 
                    LabelDataMember="Ticker" 
                    ValueDataMember="AbsoluteActualValue"/> 
            </dxc:DonutSeries.Data> 
        </dxc:DonutSeries> 
    </dxc:PieChartView.Series> 
</dxc:PieChartView>  

View Model Code

// This class is used as container for all portfolio charts. 
public class PortfolioTabItemViewModel : NotificationObject { 
    PortfolioChartViewModel chartViewModel; 
  
    public PortfolioChartType ChartType { get; } 
    public PortfolioChartViewModel ChartViewModel { 
        get => chartViewModel; 
        private set => SetProperty(ref chartViewModel, value); 
    } 
  
    public PortfolioTabItemViewModel(PortfolioChartType chartType) { 
        ChartType = chartType; 
    } 
  
    public void Update(IEnumerable<IrrHistoryItem> irrHistory, IEnumerable<PortfolioItemStatistics> itemStatistics) { 
        ChartViewModel = PortfolioChartViewModel.Create(ChartType, irrHistory, itemStatistics); 
    } 
} 
  
public abstract class PortfolioChartViewModel : NotificationObject { 
    public bool ShouldShowDetail { get; } 
     
    public PortfolioChartViewModel(bool shouldShowDetail) { 
        ShouldShowDetail = shouldShowDetail; 
    } 
  
    public static PortfolioChartViewModel Create(PortfolioChartType chartType, IEnumerable data, bool isDetailedView = false) { 
        // Specific View Model initalization is here. 
    } 
} 
  
public class PortfolioDonutChartViewModel : PortfolioChartViewModel { 
    public IEnumerable Data { get; } 
     
    public PortfolioDonutChartViewModel(IEnumerable<PortfolioItemStatistics> data, bool shouldShowDetail) : base(data, shouldShowDetail) { 
        Data = data; 
    } 
} 

Model Code

public class PortfolioItemStatistics { 
    public string Ticker { get; } 
    public double OperationPrice { get; } 
    public double ActualPrice { get; } 
    public int Count { get; } 
  
    public double OperationValue => OperationPrice * Count; 
    public double ActualValue => ActualPrice * Count; 
    public double AbsoluteActualValue => Math.Abs(ActualValue); 
    public double Profit => ActualPrice - OperationPrice; 
    public double ProfitPercent => Profit / OperationPrice; 
  
    public double TotalProfit => Count * Profit; 
    public double TotalProfitPercent => TotalProfit / Math.Abs(OperationValue); 
    public double AbsoluteProfitPercent => Math.Abs(ProfitPercent); 
  
    // Other properties and methods. 
  
    public PortfolioItemStatistics(string ticker, int count, double operationPrice, double actualPrice) { 
        Ticker = ticker; 
        Count = count; 
        OperationPrice = operationPrice; 
        ActualPrice = actualPrice; 
    } 
} 

Profit/Loss Chart

The following chart is also available within the Portfolio Page. It displays Top 10 price movements by absolute value for a given stock:

To create this chart, we had to split all values into two groups: gainers and losers. The chart view displays each group using an individual series with assigned colors.

A second interesting implementation within this chart involves bar alignment against the chart’s center. Bars are attached to the chart’s top edge by default. Since we knew the maximum number of bars, we were able to calculate the required side margins to center our bars.

Note: The chart visualizes the same collection of Model objects as the Donut chart - please refer to the previous section for the model class code.

View Markup

<dxc:ChartView Rotated="true"> 
    <dxc:ChartView.Series> 
        <dxc:StackedBarSeries  
            BarWidth="{StaticResource BarWidth}" 
            Label="{StaticResource PortfolioStackedBarSeriesPositiveValueLabel}"> 
            <dxc:StackedBarSeries.Data> 
                <dxc:SeriesDataAdapter  
                    DataSource="{Binding ChartViewModel.Losers}" 
                    ArgumentDataMember="Ticker"> 
                    <dxc:ValueDataMember Type="Value" Member="AbsoluteProfitPercent" /> 
                </dxc:SeriesDataAdapter> 
            </dxc:StackedBarSeries.Data> 
        </dxc:StackedBarSeries> 
        <dxc:StackedBarSeries  
            BarWidth="{StaticResource BarWidth}"  
            Label="{StaticResource PortfolioStackedBarSeriesPositiveValueLabel}"> 
            <dxc:StackedBarSeries.Data> 
                <dxc:SeriesDataAdapter  
                    DataSource="{Binding ChartViewModel.Gainers}" 
                    ArgumentDataMember="Ticker"> 
                    <dxc:ValueDataMember Type="Value" Member="AbsoluteProfitPercent" /> 
                </dxc:SeriesDataAdapter> 
            </dxc:StackedBarSeries.Data> 
        </dxc:StackedBarSeries> 
    </dxc:ChartView.Series> 
    <dxc:ChartView.AxisX> 
        <dxc:QualitativeAxisX> 
            <dxc:QualitativeAxisX.Range> 
                <dxc:QualitativeRange SideMargin="{Binding ChartViewModel.SideMargin}"/> 
            </dxc:QualitativeAxisX.Range>  
        </dxc:QualitativeAxisX> 
    </dxc:ChartView.AxisX> 
    <dxc:ChartView.AxisY> 
        <dxc:NumericAxisY Visible="False"/> 
    </dxc:ChartView.AxisY> 
</dxc:ChartView> 

View Model Code

public class PortfolioBarChartViewModel : PortfolioChartViewModel { 
    public IEnumerable<PortfolioItemStatistics> Losers { get; } 
    public IEnumerable<PortfolioItemStatistics> Gainers { get; } 
    public double SideMargin { get; } 
    public string VisualMax { get; } 
    public string VisualMin { get; } 
  
    PortfolioBarChartViewModel(IEnumerable<PortfolioItemStatistics> losers, IEnumerable<PortfolioItemStatistics> gainers, double sideMargin, string visualMin, string visualMax, bool shouldShowDetail) : 
        base(shouldShowDetail) { 
        Losers = losers; 
        Gainers = gainers; 
        SideMargin = sideMargin; 
        VisualMin = visualMin; 
        VisualMax = visualMax; 
    } 
} 

Question for Xamarin developers: Would you like us to extend the functionality of our Xamarin Chart control so that it paints the values of a single data series using different colors based upon specific logic? Feel free to post your thoughts in the comment section below or email support@devexpress.com.

Historical Price Charts

The following chart displays a ticker price and volume change over time. Users can select a specific time frame (1 minute, 1 hour, etc.) and series type (area or stocks) as desired.

This page utilizes several important chart-related features:

• Multiple axes: Different Y-axes measure the Price and Volume series.

• Adapting the Y-axis range to actual visible values:

• Hiding intervals without data on the X-axis:

  For example, time intervals between December 17, 5:30 AM and December 18, 11:30 AM are hidden in the animation below.

The following snippet demonstrates how we configured our chart view to display data for this advanced usage scenario:

View Markup

<dxc:ChartView> 
    <dxc:ChartView.AxisX> 
        <dxc:DateTimeAxisX 
            x:Name="axisX" 
            EmptyRangesVisible="False"> 
            <dxc:DateTimeAxisX.Range> 
                <dxc:DateTimeRange 
                    SideMargin="1" 
                    VisualMin="{Binding RangeStart}" 
                    VisualMax="{Binding RangeEnd}"/> 
            </dxc:DateTimeAxisX.Range> 
        </dxc:DateTimeAxisX> 
    </dxc:ChartView.AxisX> 
    <dxc:ChartView.AxisY> 
        <dxc:NumericAxisY 
            AlwaysShowZeroLevel="False" 
            AutoRangeMode="VisibleValues"> 
            <dxc:NumericAxisY.Layout> 
                <dxc:AxisLayout Anchor1="0.333" Anchor2="1.0" /> 
            </dxc:NumericAxisY.Layout> 
        </dxc:NumericAxisY> 
    </dxc:ChartView.AxisY> 
    <dxc:ChartView.Series> 
        <dxc:CandleStickSeries 
            Visible="{Binding IsCloseOnlyShown, Converter={converters:InverseBoolConverter}}"> 
            <dxc:CandleStickSeries.Data> 
                <dxc:SeriesDataAdapter 
                    DataSource="{Binding Content}" 
                    ArgumentDataMember="Timestamp"> 
                    <dxc:ValueDataMember Type="Open" Member="Open"/> 
                    <dxc:ValueDataMember Type="High" Member="High"/> 
                    <dxc:ValueDataMember Type="Low" Member="Low"/> 
                    <dxc:ValueDataMember Type="Close" Member="Close"/> 
                </dxc:SeriesDataAdapter> 
            </dxc:CandleStickSeries.Data> 
        </dxc:CandleStickSeries>             
        <dxc:AreaSeries 
            Visible="{Binding IsCloseOnlyShown}"> 
            <dxc:AreaSeries.Data> 
                <dxc:SeriesDataAdapter 
                    DataSource="{Binding Content}" 
                    ArgumentDataMember="Timestamp"> 
                    <dxc:ValueDataMember Type="Value" Member="Close"/> 
                </dxc:SeriesDataAdapter> 
            </dxc:AreaSeries.Data> 
        </dxc:AreaSeries> 
        <dxc:BarSeries> 
            <dxc:BarSeries.Data> 
                <dxc:SeriesDataAdapter 
                    DataSource="{Binding Content}" 
                    ArgumentDataMember="Timestamp"> 
                    <dxc:ValueDataMember Type="Value" Member="Volume"/> 
                </dxc:SeriesDataAdapter> 
            </dxc:BarSeries.Data> 
            <dxc:BarSeries.AxisY> 
                <dxc:NumericAxisY 
                    Position="Far" 
                    AutoRangeMode="VisibleValues"> 
                    <dxc:NumericAxisY.Layout> 
                        <dxc:AxisLayout Anchor1="0.0" Anchor2="0.333" /> 
                    </dxc:NumericAxisY.Layout> 
                </dxc:NumericAxisY> 
            </dxc:BarSeries.AxisY> 
        </dxc:BarSeries> 
    </dxc:ChartView.Series> 
</dxc:ChartView>

View Model Code

public abstract class InitializableViewModel<TContent> : BaseViewModel, IInitializableViewModel, IErrorHandler { 
    public TContent Content { 
        get => content; 
        private set => SetProperty(ref content, value, onChanged: OnContentChanged); 
    } 
    //Other properties are here. 
  
    public InitializableViewModel() : this(InitializableViewModelState.Loading) { 
    } 
  
    public InitializableViewModel(InitializableViewModelState initState) { 
        State = initState; 
    } 
     
    // Lifecycle methods that call 'SendRequestAsync' are here. 
  
    protected abstract Task<TContent> SendRequestAsync(CancellationToken token); 
} 
  
public class SymbolHistoricalPricesViewModel : InitializableViewModel<IList<HistoricalPrice>> { 
    // Inner field declaration is here. 
  
    public bool IsCloseOnlyShown { 
        get => isCloseOnlyShown; 
        set => SetProperty(ref isCloseOnlyShown, value); 
    } 
    public TimeFrame TimeFrame { 
        get => timeFrame; 
        private set => SetProperty(ref timeFrame, value, onChanged: (_, v) => { 
            localStorage.TimeFrame = TimeFrame; 
        }); 
    } 
    public DateTime RangeStart { 
        get => rangeStart; 
        private set => SetProperty(ref rangeStart, value); 
    } 
    public DateTime RangeEnd { 
        get => rangeEnd; 
        private set => SetProperty(ref rangeEnd, value); 
    } 
  
    public SymbolHistoricalPricesViewModel(ILocalStorage localStorage, string ticker, IHistoricalPriceRepository historicalPriceRepository) : base() { 
        // Inner fields initialization. 
    } 
  
    protected override Task<IList<HistoricalPrice>> SendRequestAsync(CancellationToken token) { 
        return historicalPriceRepository.GetHistoricalPrice(ticker, TimeFrame, token); 
    } 
}  

Application Source Code

Once again, this is the final post in our series. You can review/download the complete source code for this app using the following link: Stock Market App.

Your Feedback Matters

As always, if you’ve yet to try our Xamarin.Forms UI controls or would like to discuss your business needs further, please comment below or write to us at info@devexpress.com.

First and foremost, we hope all of you are safe and in good health.

The COVID-19 pandemic has impacted all four corners of the globe. If you've been affected (directly or indirectly), please feel free to contact our Client Services Team for assistance. We are here to help and will do whatever we can to accommodate your needs.

The Spread of the Virus

Impulze recently published a dashboard that illustrates the scope of the pandemic. If you've used DevExpress Dashboard in the past, you may be familiar with some of the visualizations used. Our thanks to  Daniel Hall, Dwayne Mithoe, Euric Santi, and Randy Wilson for sharing this app with us. 

The numbers are certainly scary. Please stay safe and follow WHO guidelines to help "flatten" the transmission curve. Together, we’ll get through this.

Before I describe our plans for our three online training courses, I wanted to wish all of you the very best. Here’s hoping everyone is safe and in good health. We are in this together so if DevExpress can be of assistance, please do reach out to us and let us know how we can help in this difficult time.

As you already know, the event industry has been hit hard by the COVID-19 pandemic. Cancellations have affected many and our best wishes go out to those affected.

For those of us who plan, manage and attend developer events, the pandemic has forced us to reimagine our roles and responsibilities. Since we cannot attend live events, we’ve been asked to place all of our energy on improving educational content on DevExpress web properties. More to come on this later but for now, I’m hoping for feedback from those of you who’ve used our paid online tutorials.

Online Training

A few years back, we published 3 online training courses (WinForms, WPF, ASP.NET WebForms) and I updated two of those courses a little over 18 months ago. If you are unfamiliar with these online training courses, please visit:

https://www.devexpress.com/trainingcenter/#Courses

We are currently refreshing these courses and expect to publish updated versions shortly. Before we publish new versions, I wanted to reach out and ask for suggestions/feedback. I’d love to know how we can improve these courses to better serve your needs going forward. Please consider this an open-ended question. I’m happy to take all suggestions and feedback into account, including requests for new courses.

We were just as disappointed as you were when we had to cancel Carl Franklin’s Roadshow because of the COVID-19 pandemic. Like you, we are now working from home and self-isolating as much as we can (or have to), and looking after our families.

Yet, Blazor is not going away, it’s growing in importance, and we at DevExpress, along with Carl, want to make sure that his presentation is seen by as many interested full-stack .NET devs as possible.

Hence the new Carl Franklin’s Blazor Desk Show series of webinars! Just like the Roadshow of yore, but as a virtual presentation. No need to drive anywhere, just settle back in your chair at your desk and watch online. Even better, we’ve arranged to repeat each webinar three times in a day: just choose the time in your time-zone that suits you best.

To recap: Carl will be presenting lots of practical information about using Blazor in your web applications. Best practices, authentication, consuming generic components, how to call JavaScript, server vs client: the topics he’ll discuss and illustrate in code are almost endless. And just to whet your appetite even more, you'll also be introduced to some exciting Blazor controls from DevExpress, including a data grid and appointment scheduling component. The materials and slides will be shared.

For information on dates and times and links, please visit the Desk Show website. I’ll warn you though: the first date is tomorrow, Thursday March 26!

Interesting Support Tickets

All Platforms

• How to group DataGrid rows when the number of items is greater than one (T668464)
• How to switch our HtmlEditor to full screen mode (T858418)
• List - How to use an entire item as a drag handler (T874123)
• DataGrid/TreeList - How to implement visual indication for the allowHiding option (T867774)

Angular

• DataGrid - How to hide the last group row on DataGrid pages (T846829)
• DataGrid - How to show/hide the master-detail expand button conditionally (T866852)
• DateBox - How to show week numbers in the Calendar (T854608)
• How to update a DateBox value in code (T873943)
• DataGrid - How to display images in Filter Row's drop-down editor for a Boolean column (T873585)
• Form - How to prevent form elements from disappearing when resizing a browser window (T873194)

Vue

• Form - How to pass data to a template (T845050)
• Scheduler - How to only display a specific week's data cells (T836489)

React

• TabPanel - How to reorder panel items via drag and drop (T846107)
• React Template - How to change a template theme at runtime (T847324)

Documentation & Demos Updates

New GitHub Examples

• Form with a custom item in template
• DataGrid - How to conditionally disable selection checkboxes

New Knowledge Base Articles

• Editors and Navigation widgets - How to detect when the current value or selected item was changed programmatically or by an end user

• Form - Validation and submission scenarios

It’s a difficult time for many – our hats off to the brave men and women helping heal those affected by the virus. We’ll get through this together.

We are working hard to get our next major release out the door in the next 45 days. We expect to share more information on the release and what we expect to include shortly. In the meantime, here’s this month’s edition of XAF Tips & Tricks. We hope it’s of value…

Interesting Support Tickets

• Change data access mode for all non-persistent List Views in your application
• Check if Model Differences have unusable nodes in code
• Create custom navigation items and manage them in the Model Editor
• Filter a user's roles based on custom logon parameters
• Note that the Office Module uses RichEditDocumentServer instead of RichEditControl to perform mail merge
• Specify time in a Report Parameter when displaying a preview
• Change loading panel text dynamically in ASP.NET applications
• Show pop-up windows in ASP.NET applications - best practices
• Connect your XPO ASP.NET Core apps to multiple databases
• Learn how to migrate your existing WinForms and WebForms projects to XAF Blazor UI
  

Usability & Performance Enhancements

• When used in Batch Edit Mode, ASPxGridListEditor correctly displays new item rows with validation rules
• We enhanced the performance of ASP.NET List Views with many reference columns (when used in Batch edit mode)
• OurLocalization Service now includes a Show Calculated Values checkbox. When this option is unchecked, the service hides items you don't ordinarily need to localize: calculated values, items without a value in a default language, and values that contain property names (for example, ObjectCaptionFormat, DisplayFormat).
  
  

Documentation Updates

Simplified Permission Checks in Custom Code

We extended the SecurityStrategy class with numerous methods you can use to check if a user can perform CRUD operations: IsGrantedExtensions. For supplementary information, please review the following article: How to: Display a List of Users Allowed to Read an Object.

List View Data Access Modes

We have redesigned online documentation for the following important concepts and added comparison tables. We also fully documented our new ServerView and InstantFeedbackView modes.

• List View Data Access Modes
• Server, ServerView, InstantFeedback, and InstantFeedbackView Modes

Please let us know if this information is of value or if you feel we need to add additional content to help you select the appropriate mode for specific usage scenarios.

Simplified Access to Detail View Editors

You can now avoid ViewItem.ControlCreated and other event handlers for many common usage scenarios - simply use our DetailView.CustomizeViewItemControl method inside the OnActivated method to customize View item controls. You no longer need to unsubscribe from events or check whether controls are created. Please let us know your thoughts.

using DevExpress.ExpressApp;
using DevExpress.ExpressApp.Editors;
using DevExpress.XtraEditors;
// ...
public class SetMinValueController : ObjectViewController<DetailView, DemoTask> {
    protected override void OnActivated() {
        base.OnActivated();
        View.CustomizeViewItemControl(this, SetMinValue);
    }
    private void SetMinValue(ViewItem viewItem) {
        SpinEdit spinEdit = viewItem.Control as SpinEdit;
        if (spinEdit != null) {
            spinEdit.Properties.MinValue = 0;
        }
    }
}​

Security System - New Code Example & KB Article

This GitHub repository demonstrates how to generate database updater code for security roles created via the application UI in a development environment. This KB article explains how to prevent deletion of the last active Administrator and the last administrative role with active users.

Our best wishes to everyone in the developer community – we hope you and your families are doing well in this difficult time period.

The following is a list of the most interesting support tickets we answered in March. We hope you’ll find them useful as you explore and use our WPF product line. If you’d like to share a support ticket with other members of the DevExpress dev community, feel free to comment below or email us at wpfteam@devexpress.com.

WPF Data Grid

• How to specify different data sources for WPF ComboBoxEdit editors per individual row (T868447)
• How to bind the Format property to a property in a ViewModel (T873237)
• How to automatically apply best fit to columns when GridControl is bound to InfiniteAsyncSource (T871658)
• How to maintain ButtonEdit button visibility within a GridColumn (T870277)
• How to declare an inplace hyperlink so it opens an email client with the specified address automatically (T868389)
• How to hide the Expand button in certain nodes (T868174)

WPF Editors

• How to apply the ItemTemplate to an item in the ComboBoxEdit editor box (T872289)
• How to select a null or empty value in ComboBoxEdit (T869067)
• How to specify custom check/uncheck glyphs for items in the drop-down popup when ComboBoxEdit is in Checked mode (T874806)

WPF MVVM

• How to use DialogService in an async method (T874300)
• Should I use PRISM for dependency injection? (T871521)
• How to display a transparent dialog window using DialogService (T870513)

Other Controls

• How to execute a command when a tab item is selected (T868931)
• How to prevent badges from being drawn over expanded auto-hidden panels (T867809)
• How to handle the ProcessNewValue event when ComboBoxEdit is defined in BarEditItem (T872336)
• How to bind elements in LayoutGroup.HeaderTemplate to the view model (T875360)
• How to make custom inner editors read-only depending on DataLayoutControl's IsReadOnly property (T870129)
• How to hide the Time Ruler in WeekView (T874699)
• How to specify width for an expanded auto-hidden panel (t874609)
• How to access properties of a property definition in PropertyDefinitionTemplate (T873609)

Should you have any questions or issues related to any of these tickets, feel free to submit a comment below or respond directly to the ticket within Support Center.