ctodx

DevExpress VCL Subscription v21.2 released

Julian Bucknall (DevExpress) — Wed, 15 Dec 2021 09:15:00 Z

Slightly later than expected perhaps, we’ve just released v21.2 of the DevExpress VCL Subscription product. The reason for the delay? Well, as can be seen from our previous announcement we have been working really hard on providing the Early Access Preview of the new ExpressCharts package as part of this release, currently available to active subscribers only.

For a complete list of what’s new in v21.2, please check out devexpress.com/new.

Important features, at least from my viewpoint, include:

The aforementioned ExpressCharts library
Support for Windows 11 and its rounded corners (and even in previous versions of Windows!)
Skinnable system message dialogs, and Open/Save Picture dialogs
The new Shell TreeView and Shell ListView controls (CTP)
Preview pane for file open/save dialogs
Fixed column/band modes for relevant Grid views
Baseline support for the Gantt Control
Support for interactive forms with the PDF Viewer (CTP)
Various Image List Editor enhancements

Just to emphasize though, this list is a deliberately sparse selection of the many new enhancements we’ve done for v21.2. You really should visit the What’s New page to see the full list.

As usual, we’ve listed the Resolved Issues introduced in this release from the latest version of the previous major release (follow that link to the version history page, make sure you clear any filters that may be set, and then select VCL, as well as “Resolved Issues”). That page also enables you to review the changes we’ve made from any release to any other.

Unfortunately, for every major release, no matter how hard we try and minimize the impact, some new features and enhancements are bound to cause a few breaking changes. You can see those from that same version history page: just select “Breaking Changes” instead.

I pretty much say something like this with every major release: we would not be able to produce and release such robust and full-featured controls, features, and enhancements without the invaluable help of you, our customers. By publishing surveys, reviewing comments and support tickets, we find that we can more easily focus on providing what our customers want from our products going forward. Also, you may have noticed that we’ve been publishing relevant blog posts on what we are doing, posts detailing various tips and tricks, and posts on how we aim to move forward. My strong recommendation is to monitor our community site more than ever before.

I’d like to thank everyone who provided feedback on our products throughout this year, who used and tested the v21.2 beta we produced and provided information on the issues they found, and, of course, to all our VCL customers who use our products every day in their applications. We are confident that the new controls, features, and enhancements in this new release of the VCL Subscription will strengthen and validate your trust in our libraries. Thank you, it is much appreciated.

VCL Charts - Early Access Preview (v21.2)

The DevExpress Team — Tue, 14 Dec 2021 17:00:00 Z

The next major release of our VCL Subscription (v21.2) is just around the corner. Before the official release, we wanted to share some good news that you've probably already guessed from the post title. Yes, v21.2 will ship with an early access preview (EAP) of our new product, ExpressCharts. In this post, I shall highlight the main features and capabilities the product will include in this preview.

Of course, should you have any questions or feedback on our new product, please comment below or submit a support ticket via the DevExpress Support Center. We will be happy to follow-up.

The VCL ExpressCharts Early Access Preview is available for all customers with an active DevExpress VCL Subscription. It is not available in the VCL Subscription trial version.

DirectX, GDI+, and GDI Support

The ExpressCharts Suite fully supports DirectX, GDI+, and GDI rendering and allows you to apply skins and transparency effects to chart elements. Anti-aliasing is enabled in both DirectX and GDI+ render modes and will enhance the graphical elements of charts even more.

Performance

Although the ExpressCharts Suite is currently available as an Early Access Preview, it already includes a number of optimizations that distinguish it from competing VCL chart libraries. Initial rendering is one aspect of performance that we've been concentrating on, another being what happens — and how quickly it gets redisplayed — when a chart is resized. Without a doubt though, the fastest way to display charts is to render them by using DirectX.

As we get closer to the official release for ExpressCharts (the release date is set for June 2022), we’ll share specific benchmarks for a broad range of usage scenarios. And yes, our expectation is that ExpressCharts will outperform its competitors – in some cases by a wide margin (for instance, right now ExpressCharts renders a line chart with one million points in under two seconds with DirectX, and resizing it completes in about one tenth of a second).

Multiple View/Series Types

The EAP version of the ExpressCharts Suite includes the following view/series types:

Area, Stacked Area, and Full-Stacked Area

Bar, Stacked Bar, and Full-Stacked Bar

Line, Stacked Line, and Full-Stacked Line

Donut chart

Pie chart

You and your users can change the applied chart type with a single option.

Flexible Design

You can create any number of diagrams and display any number of series/series points in each diagram.

Data Binding Modes

Each series has a DataBinding property that allows you to select the desired mode (Data-aware or Unbound) and specify the data binding options for your chart.

The code examples below show how to bind an Area series to data in these modes and plot it in a diagram.

Data-Aware

var
  ADiagram: TdxChartXYDiagram;
  ASeries: TdxChartXYSeries;
  ABinding: TdxChartSeriesDBDataBinding;
begin
  ADiagram := dxChartControl1.AddDiagram<TdxChartXYDiagram>;
  ASeries := ADiagram.AddSeries('Sales in 2020');
  ASeries.ViewType := 'Area';
  ASeries.DataBindingType := 'DB';
  ABinding := ASeries.DataBinding as TdxChartSeriesDBDataBinding;
  ABinding.DataSource := dsSales;
  ABinding.ArgumentField.FieldName := 'Region';
  ABinding.ValueField.FieldName := 'Sales';
end;

Unbound

const
  ACount = 5;
  ACountries: array[0..ACount - 1] of string = 
    ('Asia', 'Australia', 'Europe', 'North America', 'South America');
  ASales: array[0..ACount - 1] of Double = (4.28, 2.27, 3.72, 4.18, 3.11);
var
  I: Integer;
  ADiagram: TdxChartXYDiagram;
  ASeries: TdxChartXYSeries;
  ABinding: TdxChartXYSeriesUnboundDataBinding;
begin
  ADiagram := dxChartControl1.AddDiagram<TdxChartXYDiagram>;
  ASeries := ADiagram.AddSeries('Sales in 2020');
  ASeries.BeginUpdate;
  try
    ASeries.ViewType := 'Area';
    ABinding := ASeries.DataBinding as TdxChartXYSeriesUnboundDataBinding;
    ABinding.ArgumentField.ValueType := 'String';
    for I := 0 to ACount - 1 do
      ASeries.Points.Add(ACountries[I], ASales[I]);
  finally
    ASeries.EndUpdate;
  end;
end;

Customization Options

The VCL Chart Control provides an extensive API that allows you to customize chart content as needs dictate. The built-in Chart Designer (available at both design and runtime) helps you and your users preview and apply chart changes.

DevExpress Universal v21.2 released

Julian Bucknall (DevExpress) — Thu, 04 Nov 2021 08:00:00 Z

It’s that time of the year – time for our second major release of 2021. A couple of days ago we officially released v21.2 and introduced enhancements and new features across the whole of our .NET/JavaScript product portfolio (including updates to the following subscriptions/product lines: WinForms, WPF, ASP.NET/MVC, Blazor, DevExtreme, Reports, BI Dashboards, XAF, and Office File API). As is usual, however, the new version of our VCL Subscription will be released in a couple of weeks' time.

For a complete list of what’s new in this release, please check out devexpress.com/new. This particular cycle is also of major importance in that Microsoft are due to publish the release candidates for both Visual Studio 2022 and .NET 6 within a few days, and obviously our teams have been adding new functionality and features to support them both (and making sure everything continued to work as we progressed through the beta cycle).

Important features, at least from my viewpoint, include:

Support for HTML/CSS templates in various WinForms controls
Support for Windows 11 in WinForms and WPF
A Heat Map control for both WinForms and WPF
Accessible PDF support across the board, and in fact we’ve done a lot for accessibility throughout this release
Dashboard, Rich Text Editor, DropDown control, and a major set of features for the new Grid, all for Blazor
Talking of Blazor, our cross-platform .NET app development product, XAF, is deepening its support for it in leaps and bounds
So many improvements to our reporting suite that it’s hard to select even one or two to point out, but we now have a Report Viewer for Blazor and for WinUI
And of course, we’ve been doing a lot of work for .NET MAUI.

But, just to reiterate, this list was a deliberately sparse selection of the many new enhancements we’ve done for v21.2. You really should visit the What’s New page to see the full list.

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

Unfortunately, for every major release, no matter how hard we try and minimize the impact, some new features and enhancements are bound to cause a few breaking changes. You can read about the v20.1 breaking changes here, although one major one for our web-based products was ending support for Internet Explorer 11.

I’d like to thank everyone who provided feedback on our products throughout this year, who used and tested the various v21.2 betas we've produced and provided information on the issues they found, and, of course, to all our customers who use our products every day in their applications. We are confident that the new controls, features, and enhancements in v21.2 will strengthen and validate your trust in our products. Thank you, it is much appreciated.

WinForms: .NET 5 Design Time Enhancements

Julian Bucknall (DevExpress) — Wed, 30 Jun 2021 14:00:00 Z

Before I describe our new WinForms .NET 5 designer and associated design-time experience, I think a word or two is needed about how we got here and why it took so long to address the needs of our loyal (and patient) WinForms developer community.

WinForms & .NET 5 – a Short Story

With the introduction of .NET Core 3, Microsoft chose to fundamentally alter Visual Studio’s design-time experience – from both a functional perspective and from a third-party implementation perspective. The biggest change to the design-time – and the only option for WinForms moving forward – involved the use of multi-platform code (.NET Core and standard .NET Framework) delivered as a NuGet package.

Microsoft opted to split the design-time into two distinct processes and to execute these processes via different development frameworks. The actual UI (controls and designer preview) now runs within the .Net Core process. Designer UI code or the code that allow components such as ours to be designed inside Visual Studio now runs under .NET Framework 4.6 (4.8). These processes require special message protocols for communication. Furthermore, interface elements used to edit component properties (along with component wizards) must run on the standard .NET Framework. And yes, designer code cannot reference or use actual control types – it can only access control properties using names via specialized proxies.

As you can probably guess, Microsoft’s decision essentially left us with three options:

Sit tight and hope that Microsoft reverses course and addresses our needs. This did not happen.
Rewrite the entire DevExpress design-time experience with standard controls and throw-away a decade or more of work. We were unwilling to compromise and completely unwilling to go this route.

Before we describe the third choice, a quick word about option #2. Setting aside the cost and time involved with this option, had we chosen this route, our unique WinForms design-time experience would have disappeared for good. For instance, all preview-related features within primary designers (such as our WinForms Grid Designer and our Charts Designer) would have never made it to .NET Core 3.

Move our Designer UI into the .NET Core process.

Though option #3 introduced its own set of challenges (inter-process communications, etc), we chose it because it allowed us to share much of the same code base between the two major .NET frameworks. Additionally, this option gave us the ability to maintain design-time continuity between frameworks.

While we had hoped to release a major update late last year, breaking changes prevented us from doing so. The good news is that Microsoft completed its last major change (moving certain designer operations from the .NET Framework to .NET Core) in May with Visual Studio 2019 Build 16.10. Once Microsoft had officially released v16.10, we were in position to complete our redesign and deliver a relatively stable version of our .NET 5 WinForms designer.

DevExpress WinForms .NET 5 Design-Time – A Primer

[Note: To use our .NET 5 designer, you will need to install Visual Studio Build 16.10 or later alongside the .NET 5 Runtime. Of course, you will also need an active DevExpress product subscription (WinForms, DXperience, or Universal).]

Our most recent distribution (v21.1.4) includes a new DevExpress.Win.Design package. As you might surmise from the name, this package powers our Visual Studio .NET 5 design-time experience.

DevExpress.Win.Design will be installed automatically when you generate a new project using our WinForms Template Gallery. If you wish to update an existing app or create a blank project, you can install this package manually. To install manually, navigate to Visual Studio’s “Manage NuGet packages” dialog, select the DevExpress Local package feed, and install DevExpress.Win.Design from the "Browse" tab.

This new package resolves numerous .NET 5 design-time issues and introduces new .NET 5 design-time options, including smart tag menu actions. To deliver this specific capability, we created custom smart tags for key UI elements (Grid columns, Ribbon Bar Items, etc.).

New Custom .NET 5 Smart Tag

.NET 5 Application Template Gallery

.NET 5 Data Grid Designer

Limitations (unfortunately, there are some)

First, this package is only compatible with .NET 5 and does not offer design-time support for the older .NET Core 3.1 iteration.

Second, and perhaps most important, the design-time tools that rely upon Microsoft’s data source binding engine remain non-functional. This limitation cannot be sugar-coated. Without data source binding, you will not be able to create a new fully functional WinForms apps with our .NET Core designer. Yes, you will be able to construct your forms and customize UI controls as needs dictate, but you will not be able to create or assign a data source to your data-driven UI controls. This also means that you cannot auto-generate a user interface based on data (auto-generate columns, etc). To do this, you will still need to use .NET Framework 4.8.

Though we have tried our best to address this limitation, we have yet to find a reasonable workaround. We will continue to explore options in this regard and if we are able to address this matter independently from Microsoft, we will certainly share that information with all of you.

Note: This limitation does not apply to UI controls already bound to data (bound controls can be designed within the IDE).

Third, design-time docking is not yet functional: we have yet to rewrite the “docking-related” design-time code for .NET Core. Once we do, .NET Core design-time docking functionality will mirror its standard counterpart.

Getting Started

We have migrated all of our demos to .NET 5. You can now open any demo within Visual Studio (remember: v16.10 or later) and explore the capabilities of our .NET 5 design time.

The Future

As you can imagine, our new .NET Core Designer remains a work in progress. We cannot address all outstanding issues overnight – and some, like data-binding, may be impossible to work around – but we are working hard to address those matters that are under our direct control.

Your Feedback Matters

As always, we welcome your feedback and look forward to your suggestions. If you encounter an issue with our new .NET Core design-time experience, please submit a support ticket via the DevExpress Support Center. We will be more than happy to follow-up.

DevExtreme and related products: End of support for Internet Explorer 11

Julian Bucknall (DevExpress) — Thu, 10 Jun 2021 09:30:00 Z

After a lot of internal discussions over the past year, we have come to the decision to end support for Internet Explorer 11 (IE 11) with the next major update of DevExtreme and all related or dependent products. This will be version v21.2, which is due October/November 2021.

The following subsets of the DevExpress product line will be affected:

DevExtreme v21.2+, the entire product line:

DevExtreme for JQuery
DevExtreme for Angular
DevExtreme for React
DevExtreme for Vue

XAF ASP.NET Web Forms UI v21.2+, especially:

Maps Module
Dashboards Module
Office Module
Reports V2 Module
ShowViewStrategyBase.ShowMessage (this uses dxToast internally)

ASP.NET components v21.2+, notably:

All ASP.NET Core components that are based on client-side DevExtreme components
All ASP.NET MVC components that are based on client-side DevExtreme components

Dashboards v21.2+, pretty much across the board with regard to the web:

Dashboard for Web Forms
Dashboard for MVC
Dashboard for ASP.NET Core
Dashboard for Angular
Dashboard for React
Dashboard for Vue
Dashboard for JavaScript

Reports v21.2+, primarily:

Web Document Viewer
Web Report Designer
Web Query Builder

I emphasize that the decision to end IE 11 support was not made easily – we know that some of our customers do rely on IE 11 and will be adversely affected by this decision. Unfortunately, we can no longer delay the inevitable. At present, we are forced to maintain a good deal of IE 11 specific code (be it HTML, CSS, or JavaScript), let alone considering the amount of testing particular to IE 11 we have to do before releasing a new version. By ending this support, we will be better able to focus our energies on the modern web and maximize the long-term potential of our JavaScript product line.

For those of you who cannot abandon IE 11 (and are understandably dismayed by this announcement), please remember that you can continue to use v21.1 as long as necessary.

Before ending, I’d like to point to a couple of interesting facts that helped us make this decision.

Microsoft 365 Apps Say Farewell to Internet Explorer 11: As of August 17, 2021, Microsoft 365 apps will no longer support Internet Explorer 11.

“Customers have been using IE 11 since 2013 when the online environment was much less sophisticated than the landscape today. Since then, open web standards and newer browsers—like the new Microsoft Edge—have enabled better, more innovative online experiences.”

Worldwide Desktop Browser Usage Statistics: At present, IE 11 accounts for less than 3% of desktop market share (which drops to less than 0.2% when mobile browsers are included).

Your Feedback Matters

While we feel that we cannot delay this decision any longer, we do want to hear from those who will be affected by our decision to end IE 11 support. Either post your comments below, or submit a support ticket via the DevExpress Support Center.

FMX Grid: future plans

Julian Bucknall (DevExpress) — Wed, 02 Dec 2020 15:15:00 Z

A couple of weeks ago, we published the latest release of the DevExpress VCL Subscription, v20.2. Now that the Thanksgiving break is over, it's time to talk about what we plan for FireMonkey. I'm afraid that it's not the best of news: we have decided to put our FMX development on hold and not enhance the grid beta any further. There are several reasons for this decision.

1. After some three years of experimentation and development with FireMonkey, we have come to the conclusion that it is too slow for the depth of functionality and the type of controls for which we're recognized. Actually, this is something we've encountered before with C# and Xamarin Forms: we had to concede that the only way we could develop useful controls for that framework was to write them natively. In essence, we write them twice: once for iOS with Objective-C, and once for Android with Java, and then create a "simple" Xamarin Forms wrapper to expose their functionality to the C# developer. We found it was the only viable way we could produce the user experience and performance for our controls that our customers expect. Of course, as you can surmise, it’s over twice the usual work and effort to produce a useable control. With regard to our Delphi customer base, we and the team would rather concentrate on producing the best-in-class VCL controls – witness the newly released beta of the Gantt control as an example.

2. Another reason, perhaps less paramount, is that the FireMonkey framework, the API if you like, is still not extensive or detailed enough for the depth of functionality we and our customers assume from our 22 years of using and capitalizing on the VCL framework. We keep on running into functionality roadblocks that require us to write extensions to the base FMX library.

3. Finally, and I'd have to say this is a little disappointing, we just didn't get the level of interest or feedback from our customers that we were projecting. Perhaps this was due to the fact that the grid and editors beta we released wasn't extensive enough that people were ready to try it out and provide feedback on the functionality, or maybe there just isn't enough interest in FireMonkey for, say, MacOS, and hence our desktop viewpoint didn't match expectations. Again, this leads us to believe that our customer base would prefer more and better VCL controls rather than splitting the team into two to provide FMX controls as well.

The current beta of our FireMonkey grid suite will remain available as a free download for VCL Subscription customers from the Download Center. As of this point in time, we have no plans to add any further documentation or enhancements.

If you have feedback about this decision or wish to discuss it, do please email me at julianb@devexpress.com.

DevExpress VCL Subscription v20.2 released

Julian Bucknall (DevExpress) — Sun, 22 Nov 2020 19:00:00 Z

Without a doubt, this is a difficult time for all of us. If you or your business has been impacted by the pandemic, please contact us and let us know how we can help.

Despite having to get used to remote working and virtual meetings, our Delphi team have managed to provide you some great new features and enhancements in the new version, and I am pleased to announce the immediate availability of DevExpress VCL Subscription v20.2, our suite of controls for building effective Windows apps with RAD Studio, using either Delphi or C++Builder.

This release ships with numerous new features including:

the beta for a new Gantt control
replacements for the standard (yes, and boring!) open/save file dialogs that use your selected theme
various UX enhancements, including smooth scrolling in various controls, and padding for our in-place editors
a new display style for Filter Criteria in our grid, treelist, and vertical grid controls
…and much more

For a complete list of what’s new in this v20.2 release, please go to this page, and select the VCL link. Even easier, you can always navigate to devexpress.com/new and see what’s new in the latest version, whichever version number that happens to be.

As usual, we’ve listed the Resolved Issues introduced in this release (follow that link to the version history page, make sure you clear any filters that may be set, and then select VCL, as well as “Resolved Issues”). That page also enables you to review the changes we’ve made from any release to any other.

For every major release, no matter how hard we try and minimize the impact, some new features and enhancements are bound to cause a few breaking changes. You can see those from that same version history page: just select “Breaking Changes” instead.

I pretty much say something like this with every major release: we would not be able to produce and release such robust and full-featured controls, features, and enhancements without the invaluable help of our customers. By reviewing comments and support tickets, and contacting customers directly, we find that we can more easily focus on providing what our customers want from our products going forward. Also, we’ve been concentrating on publishing relevant posts on what we are doing, posts detailing various tips and tricks, and posts on how we aim to move forward. My strong recommendation is to monitor our community site for these helpful posts.

I’d like to thank everyone who provided feedback on our products throughout this year, who used and tested the v20.2 beta we produced and provided information on the issues they found, and, of course, to all our customers who use our products every day in their applications. We are confident that the new features and enhancements in v20.2 will strengthen and validate your trust in our products. Thank you, it is much appreciated.

DelphiCon 2020 kicks off tomorrow!

Julian Bucknall (DevExpress) — Mon, 16 Nov 2020 12:30:00 Z

Just a quick reminder if you’re a Delphi developer: Embarcadero’s virtual DelphiCon 2020 conference starts tomorrow, November 17, and runs until the 19th. It’ll be well worth your registering for the three days – I already have – since I’m going to bet you will learn something new that you could immediately apply in your current development work. There are some excellent speakers lined up (some of whom I’ve known for a little while shall we say, although that “John Hodges” character sounds way dubious!), with some really interesting topics in the mix.

My personal selection for sure: Functional Programming With Delphi by Nick^H^H^H^HJohn Hodges, High Performance Delphi by Primož Gabrijelčič, Leveraging High DPI in VCL Applications by Ray Konopka, and Code Faster in Delphi by Alister Christie.

See you online!

Design-Time Support for DevExpress WinForms Controls for .NET 5

Julian Bucknall (DevExpress) — Wed, 11 Nov 2020 12:00:00 Z

***UPDATE*** For the latest news about the Visual Studio WinForms Designer supporting our controls with .NET 5, please see this FAQ in our Support Center: Design-Time Support for DevExpress WinForms Controls for .NET 5 - FAQ. We shall be updating this FAQ page as and when we get more information.

Back in July this year, I announced that DevExpress controls had been enhanced such that they supported the latest .NET 5 Preview. However, I did warn that, although we’d been working hard to ensure that our WinForms controls were compatible with .NET 5, it was a different story with regard to the designer support in Visual Studio. Now that .NET 5 has been officially released along with Visual Studio 2019 v16.8, it is time to talk about what to expect from design-time tools using DevExpress WinForms v20.2.

The Good News (yes, unfortunately, some bad news will follow)

While the WinForms platform has yet to fully address important design-time issues, Microsoft has made good progress for those considering .NET 5. For example, you can call up smart tag menus for a control...

...use the control designers...

...and utilize the stand-alone designer dialogs for to set complex properties, such as the Mask Settings dialog for our recently overhauled editor input masks.

Basic operation

In order to develop a new WinForms app that targets .NET 5 with DevExpress UI controls, you should do the following:

1) Install Visual Studio 2019 version 16.9 Preview 1 with the “.NET Core development tools” option checked in the VS Installer.

2) Register the special Early Access NuGet feed as described in this help article: Setup Visual Studio's NuGet Package Manager. We’re distributing our .NET 5 controls via a separate feed because, as you’ll soon see, Microsoft still has to implement a few details that are crucial for our complete design time support.

Note: at this moment, the NuGet feed is the only way to get the latest DevExpress WinForms controls optimized for .NET 5. DevExpress WinForms v20.2 controls distributed via the classic .NET Core installer available in our Download Manager can also operate under .NET 5, but lack the design-time support.

3) In Visual Studio, make sure your application targets .NET 5.0. Go to “Project | Manage NuGet Packages...”. Select the feed you registered in step #2 and install the pre-release package with the required localization culture. Each package includes all available DevExpress WinForms controls.

4) Once the selected package has been installed, you can add DevExpress controls from the Visual Studio toolbox.

Now the Bad News – Known Issues

While design-time features/capabilities mentioned above seem to indicate that .NET 5 is ready and usable (it indeed is usable for basic WinForms controls inside Visual Studio), important limitations/issues remain with standard WinForms designer interfaces. These limitations cannot be “worked around” – these issues mean that our sophisticated WinForms controls are not fully supported in the designer at this time. Of course, Microsoft will be enhancing these interfaces in future Visual Studio builds and DevExpress WinForms design-time support will follow. At this time, we don’t have guidance from Microsoft as to when such changes will be ready and so we cannot offer exact release timeframes to our users. Some examples of why we have yet to deliver the best possible design-time experience for .NET 5:

Properties that accept custom structures (for example, DevExpress.Utils.Padding) as values can appear in the Visual Studio Properties panel. However, any attempt to edit such a property may cause the IDE to crash.
Icons are not supported for controls that appear in the Visual Studio Toolbox. You can see that in the image above.
Custom glyphs cannot be rendered at design time. Our WinForms controls that target the regular .NET Framework utilize such glyphs to indicate bound UI elements, to show a button that invokes the Data Source Configuration Wizard, etc.
Data sources and bindings are not supported in the designer and can only be specified in code.
Some interactive features, such as dragging control elements, are not supported.
Our testing has shown that the process that hosts the WinForms Designer is prone to hanging.
A few other issues exist on the performance side, but we’ll describe such problems at a later time.

As you may know, DevExpress was the first component vendor to release a commercial WinForms UI control (nearly 20 years ago). Over the years, we’ve created some very sophisticated and intricate designers for our complex WinForms UI controls. We’ve focused resources on the design-time experience because we know it matters. A great design-time experience improves productivity and reduces development costs. This is not hyperbole – it’s a simple fact.

Generally speaking, our WinForms design-time experience is not dependent upon Visual Studio’s standard designer interfaces. Hence, to deliver the same design-time experience for .NET 5 as we do for earlier versions of the .NET Framework would require an uphill climb – one that is simply impossible at this time. We’d have to:

Add smart tag menus for individual control elements (grid columns, tiles, etc).
Create custom wizards, such as the Template Gallery, Data Source Configuration Wizard, Scaffolding Wizard, etc (not yet possible).
Extended smart tags (not yet possible).
Deal with designer dialogs that do not allow you to create event handlers.
Figure out a way to work around a missing Find Panel for Visual Studio properties.
Solve the issue of type conversion for DevExpress Editors.
And sort out what t do about non-operational Assistant components.

Finally there are a few features and controls that are not available in the current version: XPO, reporting, and XtraDialogs. The reason for these missing features is not related to major technical difficulties and will be addressed in future DevExpress releases.

The Future

We are excited about the possibilities and we are doing everything we can to bring a great design-time experience to .NET 5. I wish we had better news to share today but we will definitely keep our foot on the gas pedal and figure out what we can do for those of you considering .NET 5.

Layouts, VCL, FireMonkey, and … DevExpress!

Julian Bucknall (DevExpress) — Mon, 03 Aug 2020 10:45:00 Z

Last week I was having a chat with an old “Delphi” friend, Andrea Raimondi, about DevExpress’ recent CTP release of our FireMonkey (FMX) grid for RAD Studio. For some reason he kept on veering away from that to layouts, what they are, and why they are important. After wondering what beer he was drinking, fine, says I, write me a post and I’ll publish it on the DevExpress Community blog site. A couple of hours later, I got The Email. A great discussion on using layouts with the DevExpress VCL Subscription, with a neat follow-up on FMX. Take it away, Andrea!

DevExpress Layouts: When you only look at the grid you're missing out!

Introduction

We all know what DevExpress is good at: grids, right? Maybe you know about the editing ones and, the most advanced of you may even know about the pivot grid. Well, if that is what you think, maybe it's time for you to try the Layout control. The layout control is the only (as far as I know) visible control that disappears at runtime. I know it sounds weird but in a sense that is exactly its purpose: it gives your UI structure while being completely invisible.

A small example

Let's create a layout at design time and align it to client.

Then, let's add three layout groups:

You get here with a double-click on the control. Now let's move those onto the actual layout surface by selecting them and dragging and dropping them onto the root one by one (multi-select isn't supported – noted! Ed.).

This is what you see then:

This gives you hints as to what it is set up like: it's flowing vertically and not aligned to client. Which is fine for us because now we are going to change the layout direction and something else will appear, this:

What happened? Let's align everything to client, shall we? Look:

Tabs. We did this by changing the layout direction, like so:

You get a tabbed view by simply changing a property. We will look at the look and feel later on because we can do some neat stuff with that as well.

A simple login screen

By today's standards, we might want a slightly different way to approach a login screen because doing the classic dialog doesn't really work anymore. You can do that very easily.

When working with layouts you must reason as though you were working with panels but the trick is that layouts don't require nearly as many: you can use a layout group everywhere you would otherwise use a panel.

First of all, we need it centered, therefore we add a layout group to do just that:

Now we need two groups one of which is aligned to the bottom (that's for the buttons) and another which is aligned to client inside the centered one:

Finally, we add the edits and the buttons with no labels. Why? Because those are built-in, making label controls redundant in this situation:

It would however look better if the buttons were on the same line and maybe aligned at left and right, like so:

Playing with the LayoutDirection property you can get this effect.

Do you like all those borders though? I do not, thus let's change a few ShowBorder properties in the groups and make it slightly slicker:

I have changed all the captions by modifying the "CaptionOptions" property set in both groups and items. To get a better feeling of it, I have also renamed the groups and a few other things:

Naming the layout control as "Layout" is very helpful because then you get everything much more easily recognizable. As you can see I have a very consistent naming convention, which I advise you use as well just to make your life easier.

Now though, we don't really want to see those tabs, right? Yeah you can hide them straight up, by doing so:

Let's see how it looks at runtime:

Not bad, huh!?

Look and feel

But we can do better: let's add some skinning. Make the project skin aware and add a LookAndFeel controller. Obviously in a real application you would do that on a datamodule, but let's keep it simple.

When you have done that, here comes the magic: there is a controller for layouts!

To connect the layout to the main controller just double-click on it and add a new item, like so:

To get this, when you click on the plus sign just select "Use LookAndFeel controller".

To connect it to the actual layout control, you set this property:

Now let's change the controller to a skin and run it again:

Now we're talking, right?

CTP for FireMonkey

Here cometh the real giggle though: you can do this very thing with FireMonkey as well. Unlike the VCL side, however, you need to use FireMonkey styles, but the result is incredibly similar (but not the same, at least for now).

What is missing at the moment is a tab layout but it's a CTP so it's kind of fair. It means you will have to find ways around this issue, and I have a suggestion further down, so keep reading!!!

Because we have seen the basics of how it works and because there are no major operational differences, I will start with the complete screen and walk you through what changes: first of all, if you want to test this properly you will need to do so on an Android phone. The Windows side doesn't work all that well for now, but again it's a CTP so fair enough.

When you do so – that is, testing on Android – you will get this:

So, how did I do this?

The basic idea is quite simple: here is the structure view on FMX (with appropriate names):

Note that there are no buttons and the reason for that relies on how the password button is configured:

By doing so, we spare the need for a button and make the UI lighter and snappier. (Do please note how this UI is incredibly fast!)

Advanced layout usage

One great thing about layouts is that you can do nearly anything. For example, you can use entire frames as controls. This obviously works both in VCL and in FMX (may I, once more, quietly remind you that this is a CTP, basically DX is still touching it gently, not at full steam!) and it's stunning. I do absolutely invite and encourage you to try for yourself. I can't get a picture of it running on my phone because something isn't working just right and I have no idea if it's the CTP or RAD Studio 10.4. (I tossed a coin and it came up RAD Studio ! Ed.)

Because of a lack of tabbed layouts, you may need to get creative on FMX (for example by using TFrameStand and switching frames around).

Conclusion

By this point, I think I made a compelling argument for you to try using layouts in your app: they are powerful, flexible and work cross-platform. And for FMX this is just a starting point. Oh, just one more thing: this article has been written with the RichEditor sample that comes with the DevExpress VCL Subscription. Yes, seriously. (Score! Ed.)

Thanks for a great post, Andrea!