RAD Studio 10.1 Berlin, add TeeChart to “FireUI Live Preview”

Studio 10.1 Berlin has just been released and includes the FireUI Live Preview tool to visualize forms at design-time in mobile devices and desktop (Windows / Mac OSX) machines.

Studio10_1_Berlin_TeeChart_FireUI_Live_Preview

The default application does not provide support for TeeChart control, but its very easy to add !

  • Open the LivePreview.dproj project in Studio 10.1 from:  c:\Program Files (x86)\Embarcadero\Studio\18.0\source\Tools\FireUIAppPreview
  • Edit the project’s Regs.pas unit to add the TeeChart related units (see code below)
  • Run the app (without debugging)
  • Create a new Firemonkey project, add a TChart control to see it at Live Preview (connect to your ide machine first)

There is only a minor caveat that should be easy to solve:

When adding series of data to TChart, they appear filled with random points at design-time.
However, Live Preview displays component contents without the “csDesigning” ComponentState property so the series appear empty.

Modifications to Regs.pas unit (displayed in bold font) :


unit Regs;

interface

uses
  System.Classes, FMX.Controls, FMX.ImgList,

  FMXTee.Constants,

  {$IF TeeMsg_TeeChartPalette='TeeChart'}
  {$DEFINE TEEPRO} 
  {$ENDIF}

  {$IFDEF TEEPRO}
  FMXTee.Editor.Pro,  // <-- if you have the Pro version of TeeChart
  {$ENDIF}

  FMXTee.Chart, FMXTee.Series;

implementation

initialization

  // Register here any component that is not previously registered by the framework

  RegisterClass(FMX.ImgList.TImageList);
  RegisterClass(FMX.Controls.TStyleBook);

  RegisterClass(FMXTee.Chart.TChart);
  RegisterTeeStandardSeries;

end.

Introducing TeeChart XAML

We’re excited to introduce you yet another addition to our TeeChart .NET line of products.

This time, we’re focusing on comfort and ease of use for programmers. While TeeChart for WinForms presents the programmers with a fully-featured designer, the visual support in other platforms is more lacking. I’m referring to what we call the XAML platforms: WPF, Silverlight, UWP and Xamarin.Forms.

In order to solve this usability problem, we’re making TeeChart and XAML understand each other better. Until now, if you wanted to design a chart using one of these XAML platforms, you had to place all the code to configure it by hand in the code-behind. Now, you will be able to build your charts with XAML code, as well as using the Visual Studio Designer for XAML.

We’re also introducing bindings to pretty much every property of your charts, thus enabling support for MVVM-oriented workflows. You will be able to tell the chart to grab your data from, for example, an ObservableCollection, and it will even update the series when the collection changes.

This will also bring support for Styles to your charts. Being able to set the font and background for all the charts in your window in a single declaration has never been easier!

Once TeeChart and XAML understand each other, the Visual Studio designer will be able to edit most of the properties out of the box. However, we’re not satisfied with that, and we’ll bring custom editors and designers to extend the Visual Studio designer’s functionality.

Here’s a sneak peek of what’s to come (click the image to enlarge):

presentation

Keep in tune for new announcements and details soon, including a Beta for interested clients!

Big files: XML or JSON ? TeeBI !!

TeeBI Dashboards

 

Introduction

XML and JSON are very typical text formats used to store data, designed to be more comfortable than plain old “csv” text and allowing hierarchical (parent -> child) relationships.

However, even if there are many wonderful standard libraries to process them, there is still a speed problem when loading big quantities of data (say, hundreds or thousands of megabytes).

Content has to be parsed and stored into memory structures representing the “tree” nature of data nodes and attributes, which can be very fast (milliseconds) for small files, but terribly slow (minutes !) for big ones.

TeeBI core base class (TDataItem) is an “agnostic” memory structure providing parent -> child connections, using simple arrays to store data (one array per field or column).

Pseudo-code:


TDataItem = class
Name : String;
Items : Array of TDataItem;   // <--- Children
Kind : TDataKind;  // <-- Integer, String, Float, DateTime, Boolean, or "List of TDataItem"
Data : Array of ...    //  <--  one array for each Kind: "Int32Data : Array of Int32"
end

 

With a TDataItem, loading and saving big quantities of data is insanely fast (0.2 seconds to load or save 1 million rows with 4 columns on a normal PC).

The arrays are saved / loaded to / from Streams directly in one Write / Read operation.

That means we can import data from XML or JSON (or any other format like database datasets, server connections, Excel, etc, etc) into a TDataItem and then save it to a binary TeeBI file for later reuse.


Data := TDataItemPersistence.Load( 'my data.bi ')

 

Once a TDataItem is created or loaded, we can use it in many ways:

  • Search and modify data, re-structure columns
  • Sort data by multiple fields, and by custom expressions
  • Run ultra-fast SQL-like queries and summaries against TDataItems
  • Set master -> detail relationships between different TDataItems
  • Filter rows by code or using expressions (as strings or as TExpression classes)
  • Create calculated columns (using code or expressions)
  • Merge several TDataItems
  • Compare the structure and / or full data of TDataItems to obtain difference sets
  • Present TDataItems using Grids, Charts, Dashboards and PDF output
  • Connect TDataItems to a super-fast TBIDataset (a normal memory TDataset class)
  • Export to any other format (for example XML to JSON and vice-versa)
  • Access remote TDataItems from web servers transparently
  • Apply machine-learning algorithms using R or Python Scikit-learn
  • Access basic statistics of any TDataItem or child item

 

Note to TeeChart developers:

TeeBI includes a new TBIChart control (derived from TChart) that is capable of automatically creating new chart series and fill them from any TDataItem.

BIChart1.Data := MyDataItem;

A planned new feature is to integrate the Data property editor dialog inside the normal TeeChart editor, for design-time support (zero code charting !)

 

TeeBI library is available for download at the following link:

https://github.com/Steema/BI

Supported development environments:

  • Embarcadero Studio (Delphi, C++) from XE4 version and up
  • Lazarus FreePascal
  • …and soon for Microsoft Visual Studio .NET

Several 3rd party products can be optionally used with TeeBI:

https://github.com/Steema/BI/wiki/3rd-party-supported-products

 

For more information:

Please visit the TeeBI community at Google+ and the TeeBI home website for more information and technical details.