Quantcast
Channel: ASP.NET Team Blog
Viewing all 372 articles
Browse latest View live

Blazor Components - New Charts customization, Updated Data Grid and TreeView API and more (available in v19.1.8)

$
0
0

The newest version of DevExpress UI for Blazor (v19.1.8) is now available. This update includes key enhancements for the following DevExpress Blazor components: Data Grid, Charts, TreeView and Tabs.

Data Grid

New Data Paging API

Our Blazor Data Grid component ships with an external data navigation API. Activate the grid’s paging mode (DataNavigationMode = DataGridNavigationMode.Paging) and use the following API to enable paging:

  • PageIndex - Specifies the current page index.
  • PageIndexChanged - Fires when the current page index is changed.
  • PageCount - Returns the current page count.
  • PageCountChanged - Fires when the current page count is changed.

To synchronize paging, link the grid’s API with an external navigation component using the @bind- directive:

<DxPager @bind-ActivePageIndex="@GridPageIndex" PageCount="@GridPageCount"></DxPager><DxSpinEdit @bind-Value="@GridPageNumber" MinValue="1" MaxValue="@GridPageCount"></DxSpinEdit><DxDataGrid ...
    @bind-PageIndex="@GridPageIndex"
    @bind-PageCount="@GridPageCount"
    ...>
...</DxDataGrid>
@code {
    int gridPageIndex;
    [Parameter] public int GridPageIndex {
        get => gridPageIndex;
        set { gridPageIndex = value; InvokeAsync(StateHasChanged); }
    }
    [Parameter] public int GridPageNumber {
        get => gridPageIndex + 1;
        set { gridPageIndex = value - 1; InvokeAsync(StateHasChanged); }
    }
    int gridPageCount;
    [Parameter] public int GridPageCount {
        get => gridPageCount;
        set { gridPageCount = value; InvokeAsync(StateHasChanged); }
    }
}

TreeView

Node Template Support

Our Blazor TreeView allows users to create reusable layouts for both nodes and associated content via templated UI elements. Available templates are listed below:

  1. NodeTemplate - Specifies a template for all TreeView node content. The template is the same for all nodes.
  2. NodeTextTemplate - Specifies a template for all TreeView node text. The template is the same for all nodes.
  3. Template - Specifies a template for an individual node's content.
  4. TextTemplate - Specifies a template for an individual node's text.

To learn more, please review our TreeView templates demo.

New Node Expand/Collapse Actions

You can now specify which user action expands or collapses a node. To enable this feature, set the NodeExpandCollapseAction property to one of the following actions:

  • Auto– Click (or double-click if the AllowNodeSelection property is set to “true”) a node or its expand button to expand/collapse the node.
  • NodeClick - Click a node or its expand button to expand or collapse the node.
  • NodeDoubleClick - Double click a node or its expand button to expand or collapse the node.
  • ButtonClick– Only click a node’s expand button to expand or collapse the node.
<DxTreeView @ref="@treeView"
    AllowSelectNodes="true"
    NodeExpandCollapseAction="TreeViewNodeExpandCollapseAction.NodeClick"
    ...><NodeTemplate><h4 class="d-inline-block m-0 @GetNodeCssClass(context)">@context.Text</h4></NodeTemplate>
    ...</DxTreeView>
@code {
    DxTreeView treeView;
    protected string GetNodeCssClass(ITreeViewNodeInfo nodeInfo) {
        var selectedNode = treeView.GetSelectedNodeInfo();
        var selectedStateClass = selectedNode != null &&
            selectedNode.Name == nodeInfo.Name ? "text-primary" : "text-secondary";
        var expandedStateClass = !nodeInfo.IsLeaf &&
            treeView.GetNodeExpanded(n => n.Name == nodeInfo.Name) ?"font-weight-bold" : "";
        return (selectedStateClass + " " + expandedStateClass).Trim();
    }
}

Event Source Detecting

We’ve extended the functionality of TreeViewNodeEventArgs. You can now use the TreeViewNodeEventArgs.CausedByAPI event argument to detect whether an event was raised through end-user interaction or programmatically.

<DxTreeView @ref="@treeView"
    BeforeExpand="@BeforeExpand" ...>
    ...</DxTreeView>
@code {
    protected void BeforeExpand(TreeViewNodeCancelEventArgs e)
    {
        if (!e.CausedByAPI)
            treeView.CollapseAll();
    }
}

Node API

The new GetNodesInfo method provides information about required nodes. We’ve also extended the ITreeViewNodeInfo interface to include a property option that contains information about a node’s parent.

<DxTreeView @ref="@treeView"
    AllowSelectNodes="true"
    SelectionChanged="@SelectionChanged" ...>
    ...</DxTreeView>
@code {
    protected void SelectionChanged(TreeViewNodeEventArgs e) {
        if (e.NodeInfo.Parent != null) {
            var parentSiblingNodesInfo = treeView.GetNodesInfo(n.Level ==
                e.NodeInfo.Parent.Level &&
                !string.Equals(n.Name, e.NodeInfo.Parent.Name));
            foreach (var nodeInfo in parentSiblingNodesInfo)
                treeView.SetNodeExpanded(
                    n => string.Equals(n.Name, nodeInfo.Name), false);
        }
        else
            treeView.CollapseAll();
    }
}

Charts

Point Customization

We’ve added new Blazor Charts API that allows you to customize point appearance. Handle the OnCustomizeSeriesPoint event and change how a point is drawn via the ChartSeriesPointCustomizationSettings object.

For example, you can customize a point’s visual settings (color, image, label’s text and visibility) as necessary:

<DxChart Data="@WeatherForecasts" OnCustomizeSeriesPoint="@PreparePointColor">
    ...</DxChart>
@code {
    protected void PreparePointColor(ChartSeriesPointCustomizationSettings pointSettings)
    {
        double value = (double)pointSettings.Point.Value;
        if (value > 75)
            pointSettings.PointAppearance.Color = System.Drawing.Color.Red;
        else if (value < 25)
            pointSettings.PointAppearance.Color = System.Drawing.Color.Blue;
    }
}

The following image helps illustrate the power of this new Blazor Chart feature (Point Customization):

DevExpress Blazor Charts

Chart point customization demos:

Point Customization

Point Image Customization

Point Label Customization

Tabs

With this update, DevExpress Blazor Tabs allow you to display an icon for any tab. To properly display an icon, set the CSS class of the icon to the TabIconCssClass property.

The code sample below illustrates how you can assign a custom CSS class to display an image on the first tab

<DxTabs><DxTabPage Text="Tab Page 1" TabIconCssClass=" custom-icon-css-class"><div>Tab Page 1 Content</div></DxTabPage><DxTabPage Text="Tab Page 2"><div>Tab Page 2 Content</div></DxTabPage></DxTabs>

Your Feedback Counts

As always, we welcome your feedback. Please share your thoughts below and tell us more about your Blazor-related development plans.


Blazor Components - Data Grid Layout Management and New Scroll Picker Mode (Available in v19.1.9)

$
0
0

The latest version of DevExpress UI for Blazor (v19.1.9) is now available and it includes enhancements for the DataGrid and DateEdit components.

Data Grid

Save and Restore Layout

Our Blazor Data Grid allows you to save and restore layout information. Saved layout information includes the current page, column sort order/direction, column position, and both group and filter values. Use these two new events to save and restore the grid's layout with ease:

  • LayoutChanged - o persist the grid’s layout instantly (when changed by a user).
  • LayoutRestoring - to restore a previously saved layout.

Handlers of both events accept an argument of type IDataGridLayout:

public interface IDataGridLayout {
    string SaveLayout();
    void LoadLayout(string json);
}

The string SaveLayout() method returns a string with grid layout data. The void LoadLayout(string json) method accepts the string with grid layout data (saved using the SaveLayout method) to restore the layout. Here is an example of how you can use the grid’s new API:

<DxDataGrid ...
    LayoutRestoring="@OnLayoutRestoring"
    LayoutChanged="@OnLayoutChanged"></DxDataGrid> 
@code {
     void OnLayoutChanged(IDataGridLayout dataGridLayout)
    {
        var layout = dataGridLayout.SaveLayout();
        // persist the layout in your storage
    }
    void OnLayoutRestoring(IDataGridLayout dataGridLayout)
    {
        var layout = … // restore layout from your storage
        dataGridLayout.LoadLayout(layout);
    }
}

We've also implemented similar SaveLayout and LoadLayout methods for the Data Grid. This allows you to save and restore the grid’s layout on demand.

GitHub Example

Take a look at this full Visual Studio example on GitHub which demonstrates how to save and restore Blazor Data Grid layout automatically and on demand.

Date Edit

Scroll Picker Mode

In v19.1.9, we added a new ScrollPicker mode for touch devices. You can specify a picker type using the PickerDisplayMode property:

  • Auto (default) - Mobile and tablet devices display the Blazor Date Picker using a scroll UI metaphor. Mobile devices display the Blazor Date Picker within a modal popup dialog, while tablet devices display the Date Picker in a non-modal popup. Desktop devices display the Date Picker as a calendar.
  • Calendar - All devices display a datepicker as a calendar.
  • ScrollPicker - All devices display a datepicker as a scroll picker.

DevExpress Blazor Date Edit Scroll Picker

When Scroll Picker mode is enabled, you can use the ScrollPickerFormat property to define a date format for each scroll picker element (day, month, and year). Supported formats are:

  • ddd– Specifies the day and the short name of the day of the week (15 Fri).
  • dddd - Specifies the day and the full name of the day of the week (15 Friday).
  • dd or d– Specifies only the day (15).
  • MMM– The shortened version of month name is used (Oct).
  • M,MM,or MMMM– The full version of month name is used (October).
  • y, yy, yyy, or yyyy– Four digit year is used (2019).

Specified format order defines corresponding scroll picker element order. For example, the image above demonstrates use of the "dddd MMMM yyyy" format string.

Your Feedback Matters

As always, we welcome your feedback. Please share your thoughts about these enhancements in the comment section below.

Blazor - Roadmap 2020 (Half-Year) - Your Vote Counts

$
0
0

The initial release of DevExpress UI for Blazor is now available. If you’re new to Blazor or are considering it for an upcoming project, feel free to download and install our products free-of-charge (Yes, our initial release is available for free).

As the title of this blog post suggest, we are preparing for 2020 and want to engage the DevExpress developer community to help fine-tune our Blazor Roadmap for the first half of 2020. Please take a few moments to review the following and vote for the Blazor-related products/features you’d like us to ship in the first half of 2020.

New Components

Help us prioritize our list of new Blazor components:

Enhancements

Cast your vote and help us prioritize the following Blazor-related features/capabilities. Please limit your selection/vote to those features you consider most important/relevant.

Data Grid

Scheduler

Pivot Grid

Data Editors

Have We Missed Something?

If a Blazor product/feature is not listed in this survey, please comment below and share your usage scenarios with us.

ASP.NET - Grid And Card View - Edit Form Layout Runtime Customization - v19.2 (Now Available)

$
0
0

In our most recent release (v19.2), we added a major enhancement to the ASP.NET GridView and CardView controls for both ASP.NET WebForms and MVC platforms.

When you use a predefined or custom Edit Form, you often need to change the layout on the fly. For example, you may need to show/hide specific items or groups of items based on user actions, user permissions, or the values (or state) for the row that needs editing. While there is the existing CellEditorInitialize event, it does not provide access to the layout items for the Edit Form.

To solve this issue in an elegant way, we've implemented runtime customization of Edit Form layout items (such as editors, buttons, layout groups) based on various conditions either on the server or client. For example, here's the GridView's Edit Form controlling the visibility of the 'Dismissal Information' group tab on the client-side. When the user enters a value for the 'Dismissal Date', the tab is shown, otherwise, a blank value hides the tab:

DevExpress ASP.NET GridView - Edit Form

To access layout items and change their settings on the server side, use the new EditFormLayoutCreated event.

protected void grid_EditFormLayoutCreated(object sender, DevExpress.Web.ASPxGridViewEditFormLayoutEventArgs e) {
    ASPxGridView gridView = sender as ASPxGridView;
    LayoutGroup layoutGroupDismissal = (LayoutGroup)e.FindLayoutItemOrGroup("DismissalInformation"); 
    if(layoutGroupDismissal == null) return; 
    if(gridView.IsNewRowEditing) {
        layoutGroupDismissal.Visible = false;
        return;
    } 
    var fireDate = gridView.GetRowValues(e.RowVisibleIndex, "FireDate");
    layoutGroupDismissal.ClientVisible = fireDate != null && (DateTime)fireDate != DateTime.MinValue;
}

The EditFormLayoutCreated event gives you the opportunity to create different layouts for different rows. You can customize the settings for new layout items or existing ones, and also remove, create, re-arrange group items, and manage row and column spans, and so on.

DevExpress ASP.NET GridView - Edit Form - Hide Elements

The following client-side methods provide access to layout items on the client side:

The example below demonstrates how to toggle an item’s visibility:

function onShowHideInfoClick(s, e) {
    var contactLayoutGroup = clientGrid.GetEditFormLayoutItemOrGroup("groupContactInfo");
    contactLayoutGroup.SetVisible(!contactLayoutGroup.GetVisible());
}

You can use a similar approach to control groups of items, including tabbed groups.

Demo: ASP.NET GridView - Edit Form Layout

CardView

The new functionality is also available in our CardView control. We populated the CardLayoutCreated event’s argument with two methods (FindLayoutItemByColumn and FindLayoutItemOrGroup), which allow you to find a layout item, and the IsEditingCard option that indicates whether the current card is being edited.

On the client, the CardView control provides the same API to manage layout items as the GridView does.

Your Feedback

I would love to hear your feedback about our ASP.NET WebForms and MVC GridView and CardView components. Drop me a line below about what functionality is required for your ASP.NET web applications.

ASP.NET Core Controls - .NET Core 3 Support and Visual Studio Enhancements (v19.2)

$
0
0

In this post, I'll discuss a couple of major enhancements to the DevExtreme ASP.NET Core and MVC Components in the latest v19.2 release.

.NET Core 3 Support

Without a doubt, .NET Core 3 is a major release that offers several cross-platform advantages over previous versions.

With the v19.2 release, I'm happy to announce support for .NET Core 3 within our ASP.NET Core product line, and this includes DevExtreme-based controls, Office-inspired controls, and Reporting.

Documentation

You can test-drive how our components use .NET Core 3 with the following documentation articles:

Visual Studio Enhancements

Form Scaffolding

Our Visual Studio Scaffolding wizard can now generate DevExtreme-based Forms from models or DTO classes.

For example, if you have a C# class that looks like this:

public class OrderDTO {
    public int ID { get; set; }

    public DateTime? ShippedDate { get; set; }

    [Required]
    public string ShipCity { get; set; }

    [Required]
    public string ShipAddress { get; set; }
}

Then our scaffolding wizard will create the following Razor markup:

@(Html.DevExtreme().Form<OrderDTO>()
    .Items(items => {
        items.AddSimpleFor(m => m.ID);
        items.AddSimpleFor(m => m.ShippedDate);
        items.AddSimpleFor(m => m.ShipCity);
        items.AddSimpleFor(m => m.ShipAddress);
    })
)

Which, at runtime, will render a fully-functional Form component, with the relevant editors powered by DevExtreme widgets:

ASP.NET Core Form Component

The scaffolding wizard will also generate the necessary form validation. For example, in that image of the generated form, notice how the editors that correspond to the fields annotated with the [Required] attribute in the C# class have been marked to require input.

Besides validation, the Form also recognizes the [Display] attribute. You can use it for labels, watermarks, and description lines. Here's how it works: if I decorate the FirstName property as shown below:

[Display(
    Name = "First name",
    Prompt = "Enter your first name...",
    Description = "As it appears on your passport or identification.")]
public string FirstName { get; set; }

Then it will render:

The Settings tab of the scaffolding wizard allows you to choose individual properties and customize form settings, such as column count or label location:

The new scaffolding wizard for the Form component will save you time and help you create forms for your web applications. We also provide scaffolding for the DataGrid and TreeList components.

Async API Controllers

Asynchronous programming, with the addition of the async/await keywords, was a welcome addition to the C# language. With this release, our scaffolder also supports async/await in API Controllers. Controllers generated by our API Controller Scaffolding Wizard are asynchronous by default. This means the controller actions are non-blocking and take advantage of the asynchronous capabilities of Entity Framework Core.

[HttpGet]
public async Task<IActionResult> Get(DataSourceLoadOptions loadOptions) {
    var products = _context.Products.Select(i => new {
        i.ProductId,
        i.ProductName,
        i.UnitPrice
    });
    return Json(await DataSourceLoader.LoadAsync(products, loadOptions));
}

ASP.NET MVC Scaffolding

As you may know, we offer two major libraries that support Microsoft's ASP.NET MVC framework. Our ASP.NET MVC controls based on DevExtreme also get the same scaffolder enhancements mentioned above.

Test It Today

Download the v19.2 update to test these new capabilities with our ASP.NET Core products today.

Then be sure to let us know your feedback. Thanks in advance!

Blazor Tips & Tricks (November 2019)

$
0
0

We thank you for your ongoing feedback and for choosing our Blazor UI controls. We hope you’ll find the following support tickets of value as you explore the capabilities of our Blazor components.

Interesting Usage Scenarios

Troubleshooting

Documentation Updates

We’ve updated our documentation for the following Blazor components:

We’ve also added/extended the following help topics:

    Our Blazor TreeView documentation includes the following updates:

    We also described the read-only state for all Data Editors and password mode for our Blazor Text Box.

    As always, we welcome your feedback. If you have specific questions or need assistance with our Blazor controls, feel free to comment below.

    Reporting for Blazor - How to use Document Viewer and Report Designer in Server-Side Blazor Apps

    $
    0
    0

    As the title of this blog post suggests, we now offer a way for you to use DevExpress Reports within your server-side Blazor apps.

    In this post I'll show you how to integrate the HTML5 Document Viewer and End-User Report Designer, part of our excellent reporting tools, into your Blazor applications. I'll focus on integration details and create a sample reporting application as well. Let's get started.

    Prerequisites

    Here’s what you’ll need to use DevExpress Reporting (our HTML5 Document Viewer and End-User Report Designer) with the Blazor framework:

    Source Code

    You can find the source code of the sample below on GitHub.

    How to Add Reporting to Blazor

    To get started, you must first create a new Blazor application using the Blazor WebAssembly App template and check the ASP.NET Core hosted option (or run dotnet new blazorwasm –hosted command). If this template was not installed, please review the following document: Get started with ASP.NET Core Blazor.

    This solution uses the ASP.NET Core backend (server-side__Blazor) to process requests from the Document Viewer and Report Designer. The client side defines the UI for these components and the logic to respond to UI updates.

    DevExpress Reports for Blazor

    Configure the Server Project

    1. Install the DevExpress.AspNetCore.Reporting NuGet package.

    2. Create a custom controller and add an action method to generate the Report Designer model based on the report URL and URIs of reporting controllers. This example uses the default DXXRD , DXXRDV and DXQB controllers of our Reporting tools to process requests from the Report Designer, Document Viewer, and Query Builder, respectively:

    namespace BlazorReporting.Server.Controllers
    {
        [Route("api/[controller]")]
        public class ReportingController : Controller
        {
            public ReportingController() { }
            [Route("[action]", Name = "getReportDesignerModel")]
            public object GetReportDesignerModel(string reportUrl)
            {
                string modelJsonScript = new ReportDesignerClientSideModelGenerator(HttpContext.RequestServices)
                    .GetJsonModelScript(reportUrl, null, "/DXXRD", "/DXXRDV", "/DXQB");
                return new JavaScriptSerializer().Deserialize<object>(modelJsonScript);
            }
        }
    }
    1. Install the Microsoft.AspNetCore.Mvc.NewtonsoftJson NuGet package to help handle sending the model to the client in the JSON format.

    2. Add server-side storage to save and load the reports. Create a new class (CustomReportStorageWebExtension), inherit it from the ReportStorageWebExtension class and define the methods. In this example, our reports are stored in memory, but you can add other storage types (database, file system, etc.) See Implement a Report Storage for more information.

    3. Open the Startup file and register the reporting services and storage:

    using DevExpress.AspNetCore;
    using DevExpress.AspNetCore.Reporting;
    // ...
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddDevExpressControls();
        services.AddMvc().AddNewtonsoftJson().AddDefaultReportingControllers();
        // ...
    }
    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        DevExpress.XtraReports.Web.Extensions.ReportStorageWebExtension.RegisterExtensionGlobal(new CustomReportStorageWebExtension());
        app.UseStaticFiles();
        app.UseDevExpressControls();
        // ...
    }

    Configure the Client Project

    1. Add the package.json configuration file and list the following npm packages required by our Reporting components:
    {"dependencies": {
        // ..."devexpress-reporting": "~19.2.3""@devexpress/analytics-core": "~19.2.3","devextreme": "~19.2.3",
      },
      // ...
    }
    1. Run the npm install command to install these packages.

    2. Create the Viewer.razor file and use the dxReportViewer binding to render the Document Viewer:

    @page "/viewer"
    @inject IJSRuntime JSRuntime
    @implements IDisposable<div id="viewer" style="width:1000px; height: 800px" data-bind="dxReportViewer: $data"></div>
    
    @code {
        protected override void OnAfterRender(bool firstRender)
        {
            JSRuntime.InvokeAsync<object>("JsFunctions.InitWebDocumentViewer");
        }
    
        public void Dispose()
        {
            JSRuntime.InvokeAsync<string>("JsFunctions.Dispose", "viewer");
        }
    }
    1. Create the Designer.razor file and use the dxReportDesigner binding to render the Report Designer:
    @page "/designer"
    @inject IJSRuntime JSRuntime
    @implements IDisposable<div style="width:1000px; height:800px" id="designer" data-bind="dxReportDesigner: $data"></div>
    
    @code {
        protected override void OnAfterRender(bool firstRender)
        {
            JSRuntime.InvokeAsync<object>("JsFunctions.InitReportDesigner");
        }
    
        public void Dispose()
        {
            JSRuntime.InvokeAsync<string>("JsFunctions.Dispose", "designer");
        }
    }

    You should use the OnAfterRender lifecycle method for both components for initialization and the Dispose method to release resources used by these components:

    1. Add the index.js file and implement the logic to initialize and dispose the components:
    var ko = require('knockout');
    
    require('devexpress-reporting/dx-reportdesigner');
    
    window.JsFunctions = {
        _viewerOptions: {
            reportUrl: ko.observable("MyReport"),
            requestOptions: {
                invokeAction: "/DXXRDV"
            }
        },
        _designerOptions: {
            reportUrl: ko.observable("MyReport"),
            requestOptions: {
                getDesignerModelAction: "api/Reporting/getReportDesignerModel"
            }
        },
        InitWebDocumentViewer: function () {
            ko.applyBindings(this._viewerOptions, document.getElementById("viewer"));
        },
        InitReportDesigner: function () {
            ko.applyBindings(this._designerOptions, document.getElementById("designer"));
        },
        Dispose: function (elementId) {
            var element = document.getElementById(elementId);
            element && ko.cleanNode(element);
        }
    }
    1. Create a new style.css file and import CSS styles:
    @import url("node_modules/jquery-ui/themes/base/all.css");
    @import url("node_modules/devextreme/dist/css/dx.common.css");
    @import url("node_modules/devextreme/dist/css/dx.light.css");
    @import url("node_modules/@devexpress/analytics-core/dist/css/dx-analytics.common.css");
    @import url("node_modules/@devexpress/analytics-core/dist/css/dx-analytics.light.css");
    @import url("node_modules/@devexpress/analytics-core/dist/css/dx-querybuilder.css");
    @import url("node_modules/devexpress-reporting/dist/css/dx-webdocumentviewer.css");
    @import url("node_modules/devexpress-reporting/dist/css/dx-reportdesigner.css");

    Add a reference to this new style.css file in the index.js file:

    require('devexpress-reporting/dx-reportdesigner');
    import "./style.css";
    // ...
    1. (Optional) You can create a bundle with Webpack as demonstrated in the GitHub example. Add a new webpack.config.js file, define the index.js file as the bundle's entry and the bundle.js file as the output file.
    module.exports = {
        entry: './src/index.js',
        mode: "development",
        output: {
            path: path.resolve(__dirname, '../wwwroot/site'),
            filename: "bundle.js"
        },
        // ...
    };

    Run the webpack command within the console to create the bundle. Link resulting files in the index.html file.

    Run and View Report

    Run the solution and view our sample in your local browser:

    DevExpress Reports for Blazor - Report Designer

    Please test this example and share your thoughts in the survey at the end of this post.

    Your Feedback Counts

    As always, we welcome your feedback. Please take a moment to answer the following survey question so we can better understand your Blazor reporting requirements.

    ASP.NET WebForms and MVC Roadmap 2020 - Your Vote Counts

    $
    0
    0
    As always, we thank you for your continued support and for placing your faith in our ASP.NET products and web technologies.
    We are in the process of finalizing our 2020 roadmap for ASP.NET WebForms and MVC. To create the best possible set of features/products in 2020, please take a moment to review the following and share your thoughts/opinions with us.

    Note: Please remember to review the following blog posts for information on other DevExpress web development technologies:
    Web Reporting
    JavaScript (Angular, React, Vue, jQuery)
    ASP.NET Core – coming soon

    ASP.NET Gantt Control

    We expect to officially launch our ASP.NET Gantt control in 2020. We hope to extend its capabilities with the following features:
    • Localization support
    • Touch device support
    • Integrated toolbar
    • Current Time Maker that indicates the current date and time within the Gantt region
    • Custom colors for Task nodes within the Gantt area
    • Customizable Context Menu
    • Customizable Task Details dialog (used to edit tasks)
    • Data validation support

    ASP.NET Diagram Control


    Like our Gantt control, we expect to officially release our ASP.NET Diagram control in 2020. New features will include:
    • Localization support
    • API to manage changes to the Diagram’s data model
    • Template-enabled custom shapes
    • Improved Diagram UI with an additional workspace inside the control
    • Improved user experience including mobile device support
    • Image shapes
    • Support for dash, dot, and other types of lines for shapes and connectors
    • Custom toolbar items
    • Auto-creation and shape connection once a connector is generated
    • Drawing- related performance enhancements
    • Context menu
    • Support for touch-first devices

    ASP.NET RichEdit

    We expect to add WYSIWYG client-side PDF export to our ASP.NET Rich Edit control in 2020.

    And Much More…

    As you know, we currently ship over 200 ASP.NET WebForms controls and MVC extensions. Throughout 2020, we expect to introduce new capabilities to our most important WebForms and MVC products (such as our Data Grid, Pivot Grid, etc). Help us prioritize our efforts – tell us what’s most important to you by answering the following two questions:

    We will publish our official 2020 Roadmap in early January. Until then, feel free to post 2020-related comments below.

    Blazor

    Considering Blazor for an upcoming web project? Be sure to review our Blazor 2020 Roadmap to learn more about our upcoming plans.

    Blazor Components - .NET Core 3.1 Support and Enhancements for the Data Grid, TreeView, and Editors (v19.1.10)

    $
    0
    0

    In this post, I'll discuss enhancements to the DevExpress UI for Blazor in the v19.1.10 release.

    .NET Core 3.1 Support

    Microsoft recently announced the release of .NET Core 3.1:

    It’s really just a small set of fixes and refinements over .NET Core 3.0, which we released just over two months ago. The most important feature is that .NET Core 3.1 is an long-term supported (LTS) release and will be supported for three years.- Richard Lander, PM .NET Team

    With the v19.1.10 release, our Blazor components now support .NET Core 3.1.

    Data Grid Enhancements

    HTML Decoration

    Our Blazor Data Grid now allows you to decorate row and cell styles. For example, you can highlight important rows or cells using this new feature.

    Our Data Grid ships with two new events: HtmlRowDecoration and HtmlDataCellDecoration. They can be used to customize row and cell appearance as needed. DataGridHtmlRowDecorationEventArgs and DataGridHtmlDataCellDecorationEventArgs event arguments provide information about the current row and cell.

    DevExpress Blazor Data Grid - Conditional Highlighting

    Demo

    Row Click

    A popular customer request is the ability to respond when the end-user clicks on a row. This release includes a new RowClick event that fires when a grid data row is clicked. The DataGridRowClickEventArgs event argument object provides information about the current row and cell.

    The code sample below illustrates how to use the RowClick event to start data editing:

    <DxDataGrid @ref="@grid"
                Data="@forecasts"
                RowClick="@OnRowClick" ...>
        ...</DxDataGrid>
    
    @code {
        DxDataGrid<WeatherForecast> grid;
        WeatherForecast[] forecasts;    ...
        void OnRowClick(DataGridRowClickEventArgs<WeatherForecast> args)
        {
            grid.StartRowEdit(args.DataItem);
            args.Handled = true;
        }
    }

    TreeView - Load Nodes on Demand

    With this release, you can bind our Blazor TreeView component with complex or dynamically generated hierarchical structures in a more effective manner. When the LoadChildNodesOnDemand setting is enabled, the component does not load child nodes until a parent node is expanded for the first time. This optimizes performance because the TreeView will only request the required data from your data source.

    You can also load child nodes on demand in either bound or unbound modes. If you bind the Blazor TreeView component to a data source, make sure to assign a lambda expression that specifies whether the data item has children (using the HasChildrenExpression property).

    Demo

    New Blazor CheckBox Component

    We now offer a Blazor СheckBox component with extended state support: checked, unchecked and indeterminate:

    DevExpress Blazor - CheckBox

    Bind to a Model

    You can bind the CheckBox to a specific model property using the Checked property:

    <DxCheckBox @bind-Checked="@Value">...</DxCheckBox>
    
    @code {
        bool Value;
    }
    

    The CheckBox component can also be bound to the following standard data types:

    Bind to a Custom Type

    If you want to bind our CheckBox to a custom type, set the ValueChecked, ValueUnchecked and ValueIndeterminate properties as necessary.

    The following example demonstrates how to bind our Blazor CheckBox to a custom enumeration using the three properties:

    <DxCheckBox @bind-Checked="@Value"
        ValueChecked="@Opinion.Yes"
        ValueUnchecked="@Opinion.No"
        ValueIndeterminate="@Opinion.Abstain">@Value.ToString()</DxCheckBox>
    
    @code{
        enum Opinion { Yes, No, Abstain }
        Opinion Value = Opinion.Abstain;
    }
    

    DevExpress Blazor - CheckBox Custom Type

    Toggle View for Mobile

    Our Blazor CheckBox also provides a toggle to change its appearance on mobile and tablet devices. Use the CheckType property to use either the standard Checkbox component or the Switch component for mobile:

    <DxCheckBox CheckType="@CheckType.Checkbox"/><DxCheckBox CheckType="@CheckType.Switch""/>

    DevExpress Blazor - CheckBox Toggle for Mobile

    Custom Appearance

    You can customize the appearance of our Blazor CheckBox using images and other HTML content:

    DevExpress Blazor - Custom Appearance

    Demo

    Blazor Data Editors - Null Values and Clear buttons

    You can bind the Spin Edit and Date Edit components to nullable data types. Currently, the following Blazor components can be bound to nullable properties:

    • Check Box
    • Combo Box
    • Date Edit
    • Spin Edit
    • Text Box

    The following code demonstrates how to bind to a nullable member:

    <DxDateEdit @bind-Date="@DateTimeValue"
        ClearButtonDisplayMode="DataEditorClearButtonDisplayMode.Auto"></DxDateEdit>
    
    @code {
        DateTime? DateTimeValue { get; set; }
    }
    

    In the sample above, the ClearButtonDisplayMode setting is optional. This setting allows the editor to display a Clear button when the editor has a non-null value:

    DevExpress Blazor - Editors - Non-Null Values

    Demo

    Form Layout - CaptionFor

    With this release, our Blazor Form Layout component will automatically bind a layout item's caption to a DevExpress editor located inside it. If you wish to assign a custom identifier to the caption's for attribute, use the CaptionFor property.

    If you place a custom editor inside the item template, assign a unique identifier to the layout item's CaptionFor setting and to your custom editor's ID property:

    <DxFormLayoutItem Caption="Contact Name:" CaptionFor="name_text_box"><Template><input value="@Name" id="name_text_box"></Template></DxFormLayoutItem>

    XAF Blazor

    For our XAF customers, we have begun rigorous testing of the DevExpress Blazor control suite within XAF, our business application framework for .NET developers. For more information, please follow the XAF Team blog.

    Feedback

    As always, your feedback matters. Please share your thoughts with us - we want to do everything possible to earn your business now and into the future.

    ASP.NET Core Roadmap 2020 – Your Vote Counts

    $
    0
    0

    Support for .NET Core Evolution

    As you would expect, we'll support the next the big release of .NET Core (currently known as .NET 5) in 2020.

    Gantt


    We will officially ship our ASP.NET Core Gantt component in 2020. We hope to extend its capabilities with the following features:
    • Localization support
    • Touch device support
    • Integrated toolbar
    • Current Time Maker that indicates the current date and time within the Gantt region
    • Custom colors for Task nodes within the Gantt area
    • Customizable Context Menu
    • Customizable Task Details dialog (used to edit tasks)
    • Data validation support

    Diagram

    Like our Gantt component, we expect to officially release our ASP.NET Core Diagram components in 2020. New features will include:
    • Localization support
    • API to manage changes to the Diagram’s data model
    • Template-enabled custom shapes
    • Improved Diagram UI with an additional workspace inside the control
    • Support for dash, dot, and other types of lines for shapes and connectors
    • Auto-creation and shape connection once a connector is generated
    • Drawing- related performance enhancements
    • Support for touch-first devices

    RichEdit

    Implement a WYSIWYG client-side PDF export.

    File Manager


    • Upload and download files via our ArrayFileProvider
    • Declarative column customization using component options
    • New API to manage file and directory selection and control end-user actions on UI elements
    • Intuitive server-side and client-side file management error handling support
    • Notification and Progress panel UX enhancements
    • Asynchronous API for server-side file modification
    • Support for file and directory access based on user roles

    HTML/Markdown Editor

    Table Support

    As you may already know, we selected the most popular open-source implementation (Quill) as the core for ASP.NET Core HTML/Markdown Editors. We constructed the control’s user interface with DevExtreme components (theme support, keyboard navigation, customization, etc).

    Quill 2.0 was expected in 2019 and was purported to offer a new API with table support. Unfortunately, Quill 2.0 has yet to be released. We now need your help to make the best possible decision about table support within our editor.

    Upload Images via a Form, Drag-and-Drop, and Copy/Paste

    We couldn’t deliver this feature in 2019. We have prepared a custom solution you can use today if this feature is important for you. We expect to integrate this feature within the control in 2020.

    Visual Studio Integration

    Accessibility

    We usually incorporate accessibility with each new ASP.NET Core feature/component. Some of you create products for government or other sectors that require strict compliance with existing accessibility standards such as Section 508 and Web Content Accessibility Guidelines (WCAG). We will compile and publish the necessary documents/materials/references for those that must meet compliance specifications/standards. 

    Improved Responsiveness/Adaptivity

    We plan to create and publish a fully responsive real-world ASP.NET Core application built from ground up. We want it to look and work perfectly on any screen – from wide desktops and tablets to mobile phones. Adaptability enhancements can be applied to many components from Toolbars and Menus to our ASP>NET Core Scheduler and DataGrid.

    DataGrid/TreeList

    New Export to Excel API

    Export to Excel will be made more flexible and robust approach via the ExcelJS library.
    Our new export capabilities will give you granular control over the Excel file generation process. We’ll do our best to make the migration process as smooth as possible. For a limited time, both options (old and new) will work side by side.
    We expect to deliver the following features prior to official release:
    • Introduce transparent (WYSIWYG) export of our DataGrid’s column format.
    • Export the DataGrid’s filter configuration as Excel worksheet column filters.
    • Fully document our new export to Excel API.
    • Demonstrate popular usage scenarios via technical demos.
    Once we finish with the DataGrid, we’ll extend the new Export to Excel API to our JavaScript PivotGrid and TreeList controls.

    Remote Validation Support

    We’ll extend Asynchronous Validation Rule support in DataGrid/TreeList cells in row and batch editing modes.

    New Splitter Component

    A Splitter allows you to divide a workspace into multiple panels (with dynamic widths). An end-user can use touch or a pointing device to resize panels at run-time.

    TreeView Drag-and-Drop Enhancements

    Node Reordering

    Change parent-child relationships of TreeView nodes via drag-and-drop.

    Cross-Component Nodes Drag-and-Drop

    Move a node from one hierarchy to another using drag-and-drop.

    Editors & Form Layout

    Label Animations

    According to Material Design Guidelines, editor placeholder text can turn into a label once the editor obtains focus. We plan to support this feature.

    Scheduler

    Our Scheduler will inherit the architectural enhancements mentioned above. If you have specific requirements, please list your needs below:

    Data Visualization

    Annotations in Maps, Pie and Polar Charts

    We recently introduced chart annotations. We plan to extend this capability to Maps, Pie and Polar Charts.

    Custom Position of Chart Axes

    We planned to release this feature in 19.2 but failed to do so. Please, refer to our discussion page for more information.

    Additional Customization Options

    We’ll allow you to use templates to render images (or other custom content) within chart axis labels.

    ASP.NET Diagram for WebForms and MVC (CTP) (v19.2)

    $
    0
    0

    Our most recent v19.2 release includes a new ASP.NET Diagram control, both for ASP.NET WebForms and for ASP.NET MVC as well.

    This new Diagram control gives you the opportunity to incorporate information-rich diagrams, flow charts, and organization charts into your apps simply and easily. It provides a visual interface with powerful formatting and data binding functionality that allows end-users to design new diagrams and modify existing ones.

    DevExpress ASP.NET Diagram Control

    Note: These components are available as a CTP (community technology preview) as we work on improving their features and functionality.

    Features

    The ASP.NET Diagram control for WebForms and MVC ships with the following basic but important features:

    • 35+ Predefined Shapes
    • Custom Shapes:

    DevExpress ASP.NET Diagram - Custom Shapes

    • Bind to Any External Data
    • Shape Sizing and Drag-and-Drop
    • Collapsible Containers
    • Auto Layout
    • ReadOnly Mode
    • Configurable Page Settings
    • Export to SVG, PNG, and JPEG images
    • Zoom and Auto Zoom
    • Full Screen and Simple View Modes:

    DevExpress ASP.NET Diagram - FullScreen

    With these features, you can design diagram types such as:

    • Flow charts
    • Organizational structures
    • Network diagrams

    End-users can design, edit, display, and export diagrams.

    Design Improvements

    We have created a brand new design concept that makes this new component's toolbars and other UI elements look more appropriate and convenient for diagram editing. You can test drive the new Diagram control by using the demo links in the 'Test it now' section below.

    Limitations and future plans

    Here are the features we're working on before the official release of the ASP.NET Diagram control:

    • An API to handle certain user actions (for example, node click and selection) and the control's data modifications
    • Image Shapes
    • AutoConnect shapes
    • Touch Support

    We plan to launch the ASP.NET Diagram controls for both the WebForms and MVC environments in the first major release of next year (v20.1).

    Test it now

    Test drive the new ASP.NET Diagram control demos here:

    Or download the latest release and test the new control in your local development environment.

    Your Feedback

    As always, we welcome your feedback. Please share your thoughts about the new ASP.NET Diagram control in the comment section below.

    ASP.NET Gantt - Data Editing, Scaling, and Undo/Redo Functionality (available in v19.2)

    $
    0
    0

    In our most recent release (v19.2), we added a few major features to our ASP.NET Gantt control. We also released a Gantt control for the ASP.NET MVC platform.

    Editing

    Our ASP.NET Gantt control allows users to modify tasks and manage resources via an integrated dialog. Invoke the edit dialog by double-clicking a task in the Gantt area:

    DevExpress MVC Gantt - Edit Task

    You can also resize and move tasks directly on the timeline or edit values in the task list:

    DevExpress MVC Gantt - Edit Task

    Once modifications are complete, the Gantt control sends a request to the server and saves the changes to the data source.

    Use the GanttSettingsEditing options to manage available edit operations for your end-users. Use the GanttSettingsEditing.Enabled property to disable editing.

    Real-time scaling

    By default, our ASP.NET Gantt component displays tasks for an entire day using the Day View. Use the GanttViewSettings.ViewType property to set a different initial view type for the chart's timeline.

    An end-user can scale the timeline by holding down the Control key and scrolling the mouse wheel. The current position of the cursor is used as the geometric center of the scaled area:

    DevExpress MVC Gantt - Zoom

    Undo/Redo Functionality

    With this release, our WebForms and MVC Gantt control tracks changes made by end-users and allows them to rollback these changes as needed:

    DevExpress MVC Gantt - Undo and Redo

    Use the Ctrl+Z and Ctrl+Y shortcuts to initiate Undo and Redo commands. Once officially released, we'll add a toolbar and corresponding buttons for this functionality.

    CTP

    Our Gantt control is available as a CTP (community technology preview) in our v19.2 release cycle. We're not quite finished with all its features but rest assured, we're working to officially release this product by May 2020.

    Test it today

    Test-drive the new ASP.NET Gantt WebForms control on your local machine. If you own an active DXperience or Universal subscription, simply download our v19.2 release from the DevExpress Client Center.

    Your Feedback Counts

    We’d like to hear from you about your development plans and needs. Feel free to leave comments below or open Support Center tickets for detailed discussions.

    For some quick feedback, please submit your responses to this short survey:

    Blazor Components - Localization, Asynchronous data operations, and more (v19.2.0)

    $
    0
    0

    This post describes the enhancements we’ve made to the DevExpress UI for Blazor in our v19.2.0 release cycle:

    .NET Core 3.1.1 Support

    Version 19.2 supports the recent .NET Core 3.1.1 update that contains security and reliability fixes.

    Localization

    You can now localize our Blazor UI components. Localization is available for both server and client side Blazor hosting models.

    For server-side Blazor projects, you can use the Satellite Resource Assemblies of the .NET Framework. We include NuGet packages with predefined satellite assemblies for German, Japanese, Russian and Spanish locales. At present, no official or recommended guidelines exist for client-side Blazor. Lacking official guidance, we opted to implement the IDxLocalizationService interface for client-side Blazor apps.

    DevExpress Blazor Localization

    For other cultures, you can use our online Localization Service to generate custom resource files as needed. Please make sure all translations meet with your approval before including them into your software project.

    Please take a look at this online example to learn more about our implementation.

    Data Grid Enhancements

    Asynchronous Data-Aware Operations

    v19.2 includes a new asynchronous data-aware API for our Blazor Data Grid.

    The new API allows you to execute database operations and await completion without blocking app code execution. This allows you to deliver more responsive solutions - even when connected to remote databases over slow networks.

    Use the new DataAsync property to data bind asynchronously. This property supports IEnumerable<T> or IQueryable<T> data source types.

    <DxDataGrid DataAsync="@ForecastService.GetForecastAsync">
        ...</DxDataGrid>

    We also introduced the following asynchronous events:

    Online demo: Data Grid - Asynchronous Data-Aware Operations

    Binding to Custom Data Source

    With this release, you can bind our Blazor Data Grid to a custom data source. Assign the data source type to the Data Grid's T parameter and use the CustomData property to implement data loading logic. The CustomData delegate accepts a DataSourceLoadOptionsBase object as a parameter. It specifies various data loading options (such as sort and group information).

    Two new extension methods for the DataSourceLoadOptionsBase class (ConvertToGetRequestUri and ConvertToHttpContent) have been added to help you generate proper requests for Web API services.

    The following example demonstrates how to bind our Blazor Data Grid to a Web API service:

    <DxDataGrid T="@WebApiOrder" CustomData="@LoadCustomData">
        ...</DxDataGrid>
    @code {
        [Inject] protected HttpClient Client { get; set; }
    
        public class WebApiOrder
        {
            public string CustomerID { get; set; }
            public DateTime OrderDate { get; set; }
            public decimal Freight { get; set; }
            public string ShipCountry { get; set; }
        }
    
        protected async Task<LoadResult> LoadCustomData(DataSourceLoadOptionsBase options, CancellationToken cancellationToken) {
            using var response = await Client.GetAsync(options.ConvertToGetRequestUri
    
                ("https://js.devexpress.com/Demos/NetCore/api/DataGridWebApi/Orders"), cancellationToken);
            response.EnsureSuccessStatusCode();
            using var responseStream = await response.Content.ReadAsStreamAsync();
            return await JsonSerializer.DeserializeAsync<LoadResult>(responseStream, cancellationToken: cancellationToken);
        }
    }

    Online demo: Data Grid - Custom Data Source

    CheckBox Column

    Our Blazor Data Grid includes a new CheckBox column with extended state support: checked, unchecked, and indeterminate.

    DevExpress Blazor Data Grid - CheckBox Column

    Use the Field property to bind the column to data:

    <DxDataGridCheckBoxColumn Field="@nameof(Order.IsShipped)" />

    You can bind the checkbox column to standard types. To bind the column to a custom type , set its ValueChecked, ValueUnchecked, and ValueIndeterminate properties:

    <DxDataGridCheckBoxColumn Field="@nameof(Order.OrderStatus)
        ValueChecked="@OrderStatus.Delivered"
        ValueUnchecked="@OrderStatus.Processing"
        ValueIndeterminate="@OrderStatus.InTransit"
        Caption="Order Status" />

    To help you filter CheckBox column data, our Blazor Data Gird creates a ComboBox editor in the filter row. Use the FilterTextChecked, FilterTextUnchecked, and FilterTextIndeterminate properties to assign custom text to the editor's dropdown items:

    <DxDataGridCheckBoxColumn Field="@nameof(Order.OrderStatus)"
        FilterTextChecked="Delivered"
        FilterTextUnchecked="Processing"
        FilterTextIndeterminate="In transit"/>

    DevExpress Blazor Data Grid - CheckBox Column Filter

    In Switch mode, the checkbox column displays toggles instead of checkboxes. To enable Switch mode, set the CheckType property to Switch.

    Scheduler

    Operation events for appointments

    v19.2 ships with new events for our Blazor Scheduler control. These events allow you to manage changes to individual appointments:

    Handle these events to modify (or discard) Drag & Drop, Data Editing, Delete, and other appointment operations before data is saved to storage.

    Online example - How to implement CRUD operations with the Web API Service

    Editors - Null Text

    NullText is a helpful feature which displays placeholder text in our ComboBox when empty.

    We've added the NullText property to the following editors:

    <DxTextBox NullText="Type text..."></DxTextBox>

    Breaking Changes - RCL Support

    In December, Microsoft introduced the Razor Class Library (RCL):

    Razor views, pages, controllers, page models, Razor components, View components, and data models can be built into a Razor class library (RCL). The RCL can be packaged and reused. Applications can include the RCL and override the views and pages it contains. When a view, partial view, or Razor Page is found in both the web app and the RCL, the Razor markup (.cshtml file) in the web app takes precedence. -Rick Anderson

    We’ve migrated our components to support RCL and to give you a native approach for sharing resources. As such, v19.2 components now require .NET Core 3.1. The RCL also uses the Blazor native location for resources (particularly, for the dx-blazor.css file).

    See the full list of breaking changes for version 19.2.

    ASP.NET WebForms and MVC - Tips & Tricks (December 2019)

    $
    0
    0

    We’vecompiled a shortlistofinterestingsupporttickets/articlesinthismonth’sTips& Tricksblogpost. 

    Ifyouhave a supportticketyou'dliketosharewiththe ASP.NET developercommunity, feelfreetopost a linkinthecommentsectionbelow. 

     

    Knowledge Base Articles

    BelowaretwoarticlesthatdescribethemostimportantaspectsofdocumentmanagementinourRichEditandSpreadsheetcontrols:

    RichEdit - General information about document management (T822829) 

    YoumayalsofindthefollowingarticlehelpfulwherewedescribedcommonaspectswhichmayleadtoYoursessionhasexpirederrormessageandthewaystoresolveit:

    RichEdit/Spreadsheet - Why the "Your session has expired" error might occur (T802885)

    Interesting Support Tickets

    Common (ASP.NET MVC and Web Forms)

    Data Annotation Attributes

    SeeourupdatedData Annotation Attributesarticlerelatedtousingdataattributesinour MVC Extensions. 

    Grid View

    Weupdatedthefollowingtopicswithcorrespondingexamplesofusing a corresponding API (clientandserver) indifferentscenarioswhileadding, updatinganddeletingrowsinGridView: 

    Spreadsheet

    Also, we described in details a common approach to useSpreadsheet Document APItoperformrequiredmodificationswithSpreadsheet Control’s document in code: 

     

     

    ASP.NET WebForms and MVC – 2020 Roadmap

    $
    0
    0

    Gantt 

    We will officially release DevExpress Gantt for WebForms and MVC in our first major release of 2020. 

    Our official release (v20.1) will include the following new features: 

    • Localization support
    • New toolbar with commands to edit default items and add custom items
    • New Current Time Marker to indicate current date and time
    • Data validation support
    • Custom task color support 
    • Touch device support

    In our second release of 2020 (v20.2), we’ll add the following capabilities to our Web Forms and MVC Gantt control:

    • Export Gantt content to PDF, PNG, etc.
    • Template support (Gantt chart tasks)
    • Context menu customization
    • Task Details dialogcustomization

    Diagram 

    We will officially ship DevExpress Diagram for WebForms and MVC in 2020. 

    Our v20.1 release will include the following features: 

    • Localization support
    • Performance enhancements
    • Custom shape templates 
    • New UI that offers additional workspace for a document. This should improve user experienceson mobile and tablet devices.
    • New shapes with images designed for use in OrgCharts.
    • Dash, dot, and other types of lines for shapes and connectors 
    • Context menu support
    • Touch device support

    v20.2 will include the following new features:

    • Toolbar and context menucustomization
    • New API to refresh Diagram document when a data model is changed outside the component
    • Text validation in shapes and connectors
    • Automatically resize shapes based on text content
    • New API to restrict end-user operations such as shape resizing, dragging, adding orremoving shapes, dragging shapes outofcontainer, etc. 
    • Shape rotation support

    RichEdit 

    Client-side PDF export (in 20.1)

    New client-side export mode generates a PDF document with the same layout as that displayed within the browser. 

    Charts

    New Swift Point Series Type (v20.2)

    Swift Point Series will be optimized for quick analysis of large input data via the use of point markers.

    swift-series

    For more information on this feature, please review the following support tickets: T752918, S34103, Q455568.

    New DateTime Scale Mode (v20.1)

    Our Chart Control includes a configurable DateTime scale (you can exclude non-working days and time as needed). We will extend DateTime scale processing by automatically excluding intervals without data. This will simplify the DateTime scale configuration for those using financial charts.

    New Series Label Display Mode (v20.1)

    All XY-Diagram compatible Series will support a new label type for easier Series identification when multiple Series are displayed simultaneously.

    edge-labels

    Support percent values for Side Margins (v20.1)

    For more information on this feature, please review the following support tickets: T700625, T148976.

    Advanced Text Formatter for Crosshair Panel (v20.2)

    You will be able to specify Crosshair label width and alignment.

    Reporting 

    Translate Report Documents to Different Languages (v20.1)

    You’ll be able to localize the text displayed in report controls and specify control location and size for a chosen language. This functionality will be available for End-User Report Designer components as well.

    Report Designer - Localized Report

    Performance Enhancements (v20.1 – v20.2)

    By refactoring our document generation engine, we expect to improve performance in terms of both memory usage and document generation speed.

    Embed PDF Documents into a Report Document (v20.1)

    You’ll be able to insert a PDF file into a report.

    Excel Export – Html-Inspired Content Support (v20.1)

    You’ll be able to export reports that contain XRLabels (with the AllowMarkupText property enabled) to Excel and preserve the content formatting.

    Excel Export – RTF Content Support (v20.1)

    You’ll be able to export reports to Excel files and preserve XRRichText content.

    Parameter Enhancements

    Bind JsonDataSource Parameters to Report Parameters (v20.1)

    You’ll be able to pass report parameter values directly to JsonDataSource.

    JSON Data Source - Parameter Bindings

    Select All Multi-Value Parameter Values By Default (v20.1)

    You’ll be able to pre-select all values for a multi-value lookup parameter.

    Numeric Range Parameter (v20.2)

    You’ll be able to create integer and float range parameters and filter a report’s data using a single editor in the parameters panel.

    Numeric Range Parameter Editor

    Parameter Editor Grouping (v20.2)

    You’ll be able to logically group multiple report parameters in the parameter panel. Editors that display parameter values are placed in a Group Box.

    Visibility of Parameter Editors (v20.2)

    You’ll be able to hide a parameter editor based on the value used for a different parameter.

    PDF Export – Visual Signatures (v20.2)

    You’ll be able to define visual signatures displayed in exported PDF files using a new report control.

    PDF Export - Visual Signature

    Excel Export – Memory Consumption Enhancements (v20.2)

    We will overhaul our Excel Export engine so you can generate large documents while consuming less memory during the export process.

    RDLC Conversion Tool (v20.2)

    Our import tool will allow you to convert your RDL / RDLC reports to DevExpress Reports.

    Document Viewer – Anchoring of Report Controls (v20.2)

    You’ll be able to use the XRControl.AnchorHorizontal property to anchor report controls when changing a report’s page settings (like orientation, paper kind and margins in Print Preview). The controls will be anchored to the specified side of a parent container.

    Anchoring in Print Preview

    New Barcode – Pharmacode Symbology (v20.2)

    This feature received 27% of the vote in our survey.

    Our XRBarCode report control will support the Pharmacode symbology.

    MongoDb Data Source (v20.2)

    This feature received 36% of the vote in our survey.

    You’ll be able to bind a report to the MongoDb database.

    Other Enhancements

    You can expect additional enhancements across our WebForms controls and MVC extensions. We will blog about these minor enhancements as we get closer to release. 


    Blazor UI - 2020 Roadmap

    $
    0
    0

    In this post, I’ll summarize our Blazor UI release plans for the first half of 2020. Should you have any questions about the products/features listed herein, feel free to submit your comments/questions below.

    As always, thank you for your continued support. Go Blazor!

    Localization (available in 19.2 Beta)

    You will be able to localize Blazor components (Blazor Server or Blazor WebAssembly) using predefined translations. You can create custom translations for your app via the DevExpress Localization Service.

    DevExpress Blazor Localization

    New Components

    Reporting Components

    Last December, we detailed how you can use our reporting tools within your blazor apps. By mid-year, we'll introduce new Blazor Reporting components which will provide better integration to help you create and manage reports.

    File Manager

    We're creating a new Blazor File Manager component to manage remote file system using standard file management operations.

    Upload

    Upload files to your server or a remote service. Our Blazor Upload component will ship with asynchronous multiple file upload, large file upload, and file extension validation support.

    Toolbar

    Our upcoming toolbar component will allow you to create useful tool buttons for popular end-user actions.

    TagBox

    The Tag Box control will allow your users to select values from a drop-down list or to enter them manually.

    Button

    Our Blazor Button component will support Contained, Outline, and Text render styles. It will ship with ten Bootstrap styles. You’ll also be able to assign icons or use a template to create a fully customized appearance.

    Data Grid

    Asynchronous Data-Aware Operations (available in 19.2 Beta)

    This new API will allow you to execute database operations and await completion without blocking app code execution. Asynch data-aware operations will help you deliver more responsive solutions - even when connected to remote databases over slow networks.

    Custom Data Binding (available in 19.2 Beta)

    You'll be able to bind our Blazor Data Grid to a custom data source, including Web API services.

    CheckBox Column (available in 19.2 Beta)

    Our new Blazor CheckBox column will allow you to display Boolean values within the Blazor Data Grid.

    Page Size Selector

    Your end-users will be able to change data page size for the Data Grid using a drop-down UI element on the pager.

    DevExpress Blazor Data Grid

    Go To Page

    End-users will be able to open a specific data page using the "Go To Page" edit box (displayed within the Data Grid's pager).

    Keyboard Support

    This feature will allow your end-users to navigate Data Grid rows via the keyboard.

    New Header Filter menu

    End users will be able to filter data by selecting a corresponding item in the Header Filter menu. You will be able to add custom items to the Header Filter menu as needed.

    New Binary Image column

    The Binary Column will allow you to display image data. You can bind this column to a property that contains images. To replace an image, the end-user should start row editing and upload a new image using the default Upload component available within the edit form.

    New Unbound column

    You will be able to use unbound columns to calculate column values based on custom algorithms (after retrieving data from the database).

    Inline Edit Mode

    Inline Edit mode will allow you to directly edit an individual row without displaying the Grid’s edit form.

    Row Template

    Row templates will allow you to create custom layouts for Data Grid rows.

    Automatically Resize to 100% Height

    When set to 100%, our Blazor Data Grid will automatically fill available height within the container element.

    Built-In Edit Forms validation

    If you use an edit form with default column editors, you no longer need to use the Blazor’s built-in validation. Our Blazor Data Grid will validate data automatically.

    Custom Values in New Rows

    At present, our Blazor Data Grid displays default values in new row cells. We will give you the ability to set custom values for new rows.

    Search Panel

    This UI element is useful when an end-user needs to search a specific value by several columns at the same time.Specific columns can be programmatically excluded from the user search.

    Toolbar

    This UI element will allow you to display toolbar buttons for custom operations and also popular operations used by your end-users.

    Context Menu

    The context menu displays popular user actions based on the user interaction, for example, a mouse click or finger tap on a UI element. You can hide default items or add custom ones to the popup menu.

    ComboBox

    Multiple Columns

    The highly requested multi-column layout feature will be available for our Blazor ComboBox in the next major release.

    Filtering Across Columns

    This feature will allow you to find items by a specific value:

    DevExpress Blazor ComboBox Filter

    Templates

    You'll be able to create custom appearances for ComboBox elements using item, header or footer templates.

    Drop-Down Position Correction

    When a ComboBox is located at the bottom of a web page, the component’s drop-down window might partially appear outside of the page. We plan to correct the window’s position automatically to always display within the available page space.

    Calendar

    Gestures

    A new gesture will allow you to change months by swiping the current month in our Calendar.

    Month and Year Navigation

    Your end-user will be able to quickly navigate between months and/or years to find a specific date.

    Common Editor Enhancements

    Interactive Null Text (available in 19.2 Beta)

    Many of you use null text to display an editor's placeholder. However, it disappears once the component has focus. We are going to keep null text visible until the user enters values.

    Loading Image

    If ComboBox or List Box is bound to a large data set, data loading operation may take some time. We plan to display a loading image for these editors to indicate the loading process.

    ASP.NET Core - 2020 Roadmap

    $
    0
    0
     
    Our thanks to everyone who reviewed our preliminary ASP.NET Core 2020 Roadmap last year. Your feedback helped us refine our development plans and to finalize our 2020 Roadmap.

    Should you have any questions about our 2020 Roadmap or if you’d like to discuss your development needs further, please post a comment below. We’ll be happy to follow up.

    Visual Studio Integration (v20.1-v20.2)

    Our new scaffolding wizard will help you generate API Controllers from eXpress Persistent Objects (XPO) models.

    We will release existing DevExtreme-based project templates with a new unified wizard. This new wizard will allow you to select.NET Core version, View type (MVC or Razor Pages), project layout (Material or Bootstrap), and a few more options.

    Official Product Release Schedule

    In 2019, we introduced and released community tech previews (CTPs) of several major components. In 2020, we expect to officially ship the following products:

    Gantt

    We will officially release ASP.NET Core Gantt in our first major release of 2020 (v20.1) with the following new features: 
    • Localization support
    • New toolbar with commands to edit default items and add custom items
    • New Current Time Marker to indicate current date and time
    • Data validation support
    • Custom task color support
    • Touch device support
    In our second major release of 2020 (v20.2), we plan to add the following enhancements to our ASP.NET Core Gantt control:
    • Export the Gantt content to PDF, PNG, etc.
    • Template support (Gantt chart tasks)
    • Context menu customization
    • Task Detail dialog customization.

    Diagram

    The Diagram for ASP.NET Core will be available in the v20.1 release and include the following features:
    • Performance enhancements
    • Custom shape templates
    • New UI that offers additional workspace for a document. This should improve user experiences on mobile and tablet devices.
    • Dash, dot, and other types of lines for shapes and connectors
    • Support for touch devices
    v20.2 will introduce the following new features:
    • Toolbar and context menu customization
    • New API to refresh Diagram document when a data model is changed outside the component
    • Text validation in shapes and connectors
    • Automatically resize shapes based on text content
    • New API to restrict end-user operations such as shape resizing, dragging, adding or removing shapes, dragging shapes out of container, etc.
    • Shape rotation support

    File Manager

    Our first release of 2020 (v20.1), will include a production version of the ASP.NET Core File Manager. It will include the following new features:
    • Upload and download files via our ArrayFileProvider
    • Declarative column customization using component options
    • New API to manage file and directory selection and control end-user actions on UI elements
    • Intuitive file management error handling support
    • Notification and Progress panel UX enhancements
    • Item hover and selection within the thumbnail view
    • Touch device support enhancements

    Improved Responsiveness/Adaptivity (v20.2 or later)

    To help you leverage the responsive capabilities of many of our ASP.NET Core controls, we're working on creating a fully responsive real-world application. We're building it from scratch with modern approaches to responsive and adaptive design. Our goal is to have it look and work perfectly on any screen - from wide desktops and tablets to mobile phones. Adaptability enhancements are supported by many of our components from Toolbars and Menus to our Scheduler and DataGrid for ASP.NET Core. 

    DataGrid/TreeList

    New Export to Excel API (v20.1)

    We plan to enhance the Export to Excel feature by leveraging the ExcelJS library which provides more flexibility and robustness.
    The new export capabilities will give you granular control when exporting Excel files. To make the migration process smooth between versions, we'll offer both options (old and new) side-by-side for a limited time.

    We expect to deliver the following features prior to official release:

    • Introduce transparent (WYSIWYG) export of our DataGrid’s column format.
    • Export the DataGrid’s filter configuration as Excel worksheet column filters.
    • Fully document our new export to Excel API.
    • Demonstrate popular usage scenarios via technical demos.

    Remote Validation Support

    We will extend the support for Asynchronous Validation Rule in DataGrid/TreeList cells for the row and batch editing modes.

    API Enhancements

    We plan to improve the design-time experience of both our DataGrid and TreeList when using MVVM-like reactive frameworks such as React, Vue, and Angular. You’ll be able to work with the component state via bindings/properties rather than via instance methods. For instance, you’ll be able to bind expanded detail row IDs in the markup instead of calling the ‘expandRow’ and ’collapseRow’ methods.
    We will allow you to track and control the following DataGrid and TreeList states:
    • Expanded group rows
    • Expanded master-detail rows
    • Expanded adaptive rows
    • DataSource properties (items, totalCount, summary)
    • Load panel visibility
    • Validation state (invalid cells, error text and position)
    In addition, we plan to introduce the following API enhancements:
    • Add new editing-related ‘saving’ and ‘cancel’ events
    • Allow you to manipulate DataGrid/TreeList data without using a CustomStore

    PivotGrid

    New Export to Excel API (v20.2)

    We received a lot of positive feedback about the new Export to Excel API mentioned above in the DataGrid section and expect to extend it to PivotGrid in 2020.

    UI Components

    Editors & Form Layout

    Label Animations (v20.1)

    According to Material Design Guidelines, editor placeholder text can turn into a label once the editor obtains focus. We will add this feature to our editor controls.

    HTML/Markdown Editor

    Table Support (v20.2 or later)

    ASP.NET Core HTML/Markdown Editor (CTP) core is based on the open-source implementation known as Quill. Quill 2.0 was expected to ship in 2019 with a new API and with table support. Unfortunately, Quill 2.0 has not been released.

    Support for tables is an important feature and therefore, we cannot release a final version of our HTML/Markdown Editor until we find a way to implement tables. If Quill 2.0 is not released or we can’t deliver this capability with Quill 1.x, this feature may not be released in 2020.

    Upload Images via a Form, Drag-and-Drop, and Copy/Paste (v20.2 or later)

    Though we were unable to deliver this feature in 2019, we have prepared a custom solution you can use today. We expect to integrate this feature once we resolve the table support issue mentioned earlier.

    Scheduler

    Hour Values within the Recurrence Form (v20.1)

    Your end-users will be able to specify the ‘hour’ portion of a recurring appointment:

    Sticky Group/Resource Names (v20.1)

    When scrolling a wide or high group, names can exceed visible boundaries. We'll enhance this with our new implementation where sticky names will remain visible during scroll operations.

    Virtual Scrolling (v20.2)

    To help improve overall performance and usability, we will add a new virtual scrolling mode to our Scheduler component. When enabled, only visible appointments will be rendered.

    Data Visualization

    Annotations in Maps, Pie and Polar Charts

    We plan to introduce the recent chart annotations feature for Maps, Pie, and Polar Charts.

    Custom Position of Chart Axes

    Chart axes are always rendered on the edges of a chart which impairs its readability. To solve this, we are going to give the chart axes the capability to intersect at any value. Please, refer to our discussion page for more information.

    Additional Customization Options

    We're adding templates to help you render images (or other custom content) within chart axis labels.
    The information contained within this blog post details our current/projected development plans. Please note that this information is being shared for INFORMATIONAL PURPOSES ONLY and does not represent a binding commitment on the part of Developer Express Inc. This roadmap and the features/products listed within it are subject to change. You should not rely on or use this information to help make a purchase decision about Developer Express Inc products.
     

    ASP.NET Core - New Syntax To Fix Razor Issue

    $
    0
    0

    In this post, I'll explain a recent issue, our proposed fix, and what you need to know if you use our ASP.NET Core controls in .NET Core 3.x apps.

    The Issue

    We discovered an issue in ASP.NET Core's Razor engine which affects the client-side template syntax used by our DevExtreme-based ASP.NET Core Controls:

    The Razor view engine can truncate parts of ERB-style constructs also known as 'percent tags' (<%= value %>) which will in turn affect your client-side templates. To see a code example of this issue and it's effects, please take a look at this GitHub issue.

    To make matters worse, at runtime, the output is empty and there are no errors in the browser console.

    While Microsoft does not have a quick fix scheduled for this issue, we've got a fix ready and I'd like to get your feedback.

    Our Fix

    We have limited options in how we can fix this issue because the problem lies in the ASP.NET framework's Razor engine. However, we've come up with a simple and useful workaround.

    We now provide an alternate syntax for client-side templates. Instead of using angle brackets (<% %>), you can use square brackets [% %] as template delimiters:

    [% if(value > 0) { %]<div>[%= value %]</div>
    [% } else { %]<div>(none)</div>
    [% } %]

    The new syntax is already available in our recently released maintenance updates 19.1.8 and 19.2.4. We've updated our documentation as well.

    If this issue is important to you, then let Microsoft know and please vote here.

    Should you have any questions about our new syntax or if you’d like to discuss your development needs further, please post a comment below. We’ll be happy to follow up.

    Blazor Components - New TagBox, Button, Theme, and more Enhancements (available in v19.2.3)

    $
    0
    0

    In this post, I'll discuss the most recent enhancements to the DevExpress UI for Blazor (v19.2.3). This update incorporates features and changes introduced in our most recent beta.

    New "Blazing Berry" Theme

    Our new "Blazing Berry" theme is now available. It was built with Bootstrap v4:

    We love the new theme so much we made it our default for our online Blazor demos.

    Download, or clone, the themes from our free open source GitHub repository here:

    https://github.com/DevExpress/bootstrap-themes

    New TagBox

    A new TagBox component has been added in this release. As you know, a TagBox is an editor which allows your end users to select or type multiple items and display them in a text area.

    Use the AllowCustomTags property to enable custom item input.

    Filtering

    Our Blazor TagBox ships with 'Contains' and 'StartsWith' filter modes. When filtering is enabled, the drop-down list is automatically filtered once an end user starts typing.

    Virtual Scrolling

    Our Blazor TagBox also supports Virtual Scrolling (to help you work with large data sources). In this mode, the TagBox loads a small item set and additional items are dynamically loaded from the server when an end user scrolls the drop-down list.

    Template

    You can customize default tag appearance using the TagBox's Tag Template.

    Data Validation

    Add our TagBox to the standard Blazor EditForm to leverage built-in Data Validation features:

    New Button

    We now offer a Blazor Button component with support for nine standard Bootstrap styles and three display modes. The Button component ships with the following states: default, hovered, focused, and disabled.

    You can also create custom buttons.

    Data Grid

    Row Preview Template

    You can now customize Blazor Data Grid rows via our preview row template. The layout of the preview section is located below each data row:

    Note: Use the ItemInfo object to retrieve regarding the current row's data object.
    <RowPreviewTemplate Context="ItemInfo"> @{ Employee employee = ItemInfo.DataItem;<table cellpadding="5" cellspacing="0"><tbody><tr><td rowspan="4" style="border: 0px;"><img src="images/Employees/@(employee.FileName).png" width="76" /></td><td style="border: 0px; white-space: normal;"> @employee.Notes </td></tr></tbody></table>
      }</RowPreviewTemplate>

    New UI Elements in Pager

    Our Blazor Data Grid offers improved UI navigation elements for paging. The new Page Size selector allows your end users to specify page size as needed. You can also add custom values to the Page Size drop-down list.

    We added a Go To Page edit box so users can navigate to a specific data page:

    We've also updated the Data Grid Pager's public API so you can manage our new UI elements.

    New Row Initialization

    This release includes a new InitNewRow event. The event allows you to set custom row values when an end user adds a new row to the grid.

    Task OnInitNewRow (Dictionary<string, object> values) {
    {
        values.Add("Field1Name", Field1Value);
        values.Add("Field2Name", Field2Value);
        ...
        return Task.CompletedTask;
    }
    Note: As the example above demonstrates, this new event handler should return the Task object so the new row will initialize asynchronously.

    Charts

    Axis Type Selections

    Typically, the Chart component automatically creates an axis depending on your data. With this release, we've now added the following axis types which can be set in code: Continuous, Discrete, or Logarithmic.

    Hide Spin Edit Buttons

    Our Blazor Spin Edit now allows you to hide spin buttons using its new ShowSpinButtons property.

    Popup

    Header and Footer

    With this release, we have improved the appearance of our Blazor Popup component. You can add custom content to the Popup's footer using the new FooterTemplate:

    The Popup can now display internal scroll bars when the dialog contains lots of content. Unless hidden, the header and footer will also be displayed with scroll bars.

    We've also added a new Visible property which can be easily bound to a Boolean field to control the popup's visibility.

    Updated XAF's Blazor UI & Example with Security System APIs

    For our XAF customers: We've updated our online XAF Blazor demo based on release versions of DevExpress Blazor components.

    Even if you do not plan to use XAF's UI, you may find this new non-XAF Blazor Server demo and tutorial helpful. It demonstrates how to use DevExpress Blazor components with XAF's non-visual APIs for user authentication and group authorization. For more information on our business application framework for .NET developers, please follow the XAF Team blog.

    ASP.NET WebForms, MVC and Core - Tips & Tricks (January 2020)

    $
    0
    0

    We’ve compiled a short list of new help topics, code examples and interesting support tickets that may be of interest to those of you using our ASP.NET Subscription. As always, feel free to share your favorite support tickets with the DevExpress developer community in the comments section below.

    New Examples

    We published several new examples onDevExpress GitHub. Please let us know if you have any questions or encounter any issues.

    Rich Edit for Angular

    Diagram for Web Forms

    File Management for ASP.NET Core

    Interesting Technical Support Tickets

    Common (ASP.NET MVC and Web Forms)

    ASP.NET Web Forms 

    ASP.NET Core

    ASP.NET MVC

    Documentation Topics

    The following article describes how you can add our ASP.NET Core RichEdit control to an Angular application.

    Add RichEdit to an Angular Application

    We also created a set of topics for the Gantt Control’s UI elements and its API members (how to manage appearance and functionality):

    ASP.NET WebForms

    TasksDependenciesResources

    ASP.NET MVC

    TasksDependenciesResources

    We also added code examples to our documentation to illustrate how to use header and cell bands in MVC GridView.

    Feedback

    Feel free to share your thoughts on these items or anything else that may be on your mind. As always, we thank you for your continued business.

    Viewing all 372 articles
    Browse latest View live