TMS Scripter 8.0 — the scripting engine that lets Delphi applications execute Pascal and Basic scripts at runtime — is coming soon, and it will be the first release to require Delphi XE2 or later. Delphi 7, Delphi 2007, Delphi 2010, and Delphi XE are no longer in the supported range.

TMS Diagram Studio, TMS Workflow Studio, and TMS Query Studio will make the same change in their own upcoming releases.

A Long-Running Commitment

TMS Scripter has supported Delphi 7 since day one — the library was born in that era, and the compatibility was maintained for roughly twenty-five years. Many TMS customers run production applications on legacy Delphi versions that cannot be easily migrated, and keeping them supported was always a deliberate choice.

But that chapter is now closed. The time has come to move forward.

Why We Are Dropping Support

Delphi 7 predates two of the most important additions to the Object Pascal language: generics and anonymous methods, both introduced in Delphi 2009. Every line of code in TMS Scripter had to be written as if those features did not exist, which created real and lasting constraints:

• Untyped collections everywhere. Without generics, lists of objects use untyped TList with manual typecasts at every access site. Code that would naturally be TList<TScript> must instead work with raw pointers and explicit casts throughout.
• Callback boilerplate. Registering Delphi methods for use in scripts requires separate named wrapper procedures for each one. Anonymous methods would allow the logic to be co-located with its registration, but that was not an option.
• No advanced RTTI. The System.Rtti unit — which allows full runtime inspection of classes, methods, properties, and their types — arrived in Delphi 2010. It is unavailable on Delphi 7 entirely, which means a scripting engine cannot use it to automatically discover and register Delphi classes. Everything has to be done manually.
• API surface limited by the lowest common denominator. Public APIs that would benefit from typed generics or procedure references had to fall back to TObject, Pointer, or method-of-object types.

This is not a criticism of Delphi 7. It had its time, and it served its users well. But maintaining compatibility with a compiler from 2002 while trying to build a modern, maintainable library is a genuine tension, and it has accumulated over the years.

What This Opens Up

TMS Scripter 8.0 itself does not yet take full advantage of the new baseline — this is the first step, not the finished product. We want to see how the community reacts before committing to deeper API changes.

What the change does is remove a hard constraint. Going forward, the codebase can evolve toward:

Generics. Internal collections can become properly typed. TList<T> instead of TList. Fewer typecasts, stronger compile-time checks, better IDE code completion.

Advanced RTTI. The System.Rtti unit gives a program full runtime knowledge of any class — its methods, parameters, return types, properties, and attributes. For a scripting engine, this is particularly powerful: instead of manually writing a wrapper procedure for every method you want to expose to scripts, the engine can potentially walk the RTTI of a class and register everything automatically. This is the kind of capability that can dramatically reduce the boilerplate burden on users and make Scripter integration with arbitrary Delphi classes much more seamless.

Anonymous methods. Callback types can be changed from method-of-object references to reference to procedure. To illustrate the kind of improvement this enables — today, registering a Delphi class method for use in a script looks like this:

// Current approach: a dedicated class with one wrapper method per Delphi method
type
  TMyLibrary = class(TatScripterLibrary)
  protected
    procedure CalculateProc(AMachine: TatVirtualMachine);
    procedure Init; override;
  end;

procedure TMyLibrary.Init;
begin
  with Scripter.AddDelphiClass(TMyCalculator) do
    DefineMethod('Calculate', 1, tkInteger, nil, CalculateProc);
end;

procedure TMyLibrary.CalculateProc(AMachine: TatVirtualMachine);
begin
  with AMachine do
    ReturnOutputArg(TMyCalculator(CurrentObject).Calculate(GetInputArgAsInteger(0)));
end;

Once the callback type supports procedure references, the same registration can be written inline:

// Future direction: registration and implementation in one place
with Scripter.AddDelphiClass(TMyCalculator) do
  DefineMethod('Calculate', 1, tkInteger, nil,
    procedure(AMachine: TatVirtualMachine)
    begin
      AMachine.ReturnOutputArg(
        TMyCalculator(AMachine.CurrentObject).Calculate(
          AMachine.GetInputArgAsInteger(0)));
    end);

None of this was possible while the library had to compile on Delphi 7. Now it is.

You Are Not Stranded: TMS Smart Setup Versioning

If you are still on Delphi 7, or on one of the other versions now leaving the support window, you are not left without options.

TMS Smart Setup — the TMS Software installer and package manager — includes a versioned installation feature designed exactly for this situation. When you use Smart Setup to install TMS Scripter, it detects which Delphi version you have and serves you the last release that supports it — automatically, without you having to track which archive corresponds to which compiler.

The end of active compatibility maintenance does not mean the last supported version disappears.

What About the Other Products?

TMS Scripter gets the headline, but it is not the only product affected.

TMS Diagram Studio — the framework for building diagram and flowchart editors in Delphi VCL applications — will drop the same set of legacy versions in an upcoming release.

TMS Workflow Studio — a workflow engine for defining and executing business processes within Delphi applications — follows the same path.

TMS Query Studio — the visual query builder component for building complex queries at runtime — likewise.

All four products share the same compatibility floor going forward: Delphi XE2 or later.

What This Means for You

If you are on Delphi XE2 or later: you are in the supported range. TMS Scripter 8.0 will install and work as usual when it releases.

If you are on Delphi 7, 2007, 2010, or XE: the last version of each product that supported your compiler remains fully functional. Use Smart Setup to install it cleanly — it will continue to work exactly as it always has.

Links

• TMS Scripter product page
• TMS Scripter documentation
• TMS Smart Setup
• Smart Setup version compatibility guide

Introduction

• Editing cells
• Sorting columns
• Filtering columns
• Paging through records

Editing Data with Built-in Cell Editors

Sorting Columns

procedure TForm1.btnSortSortableColumnClick(Sender: TObject);
var
  SO: TDGSortOrder;
begin
  case cmbSortOrder.ItemIndex of
    0: SO := TDGSortOrder.soAscending;
    1: SO := TDGSortOrder.soDescending;
    else SO := TDGSortOrder.soNone;
  end;

  WebDataGrid1.ColumnDefs.FindColumn('SortableColumn').Sort(
    SO,
    chkAddToExistingSortOrder.Checked);
end;

procedure TForm1.btnClearSortingClick(Sender: TObject);
begin
  WebDataGrid1.ColumnDefs.ClearSorting;
end;

Filtering Columns

procedure TForm1.WebFormCreate(Sender: TObject);
var
  Data, IStr, IStr2: String;
  I: Integer;
begin
  WebDataGrid1.ColumnDefs[1].Filter := True;
  WebDataGrid1.ColumnDefs[2].Filter := True;

  Data := '';
  for I := 1 to 50 do
  begin
    IStr := IntToStr(I);
    IStr2 := IntToStr(Random(100));
    Data := Data + IStr + ',"Item #' + IStr + '", ' + IStr2 + #$D#$A;
  end;

  WebDataGrid1.LoadFromCSVString(Data);
end;

procedure TForm1.btnFilterTextColumnClick(Sender: TObject);
begin
  WebDataGrid1.ColumnDefs.FindColumn('TextColumn').ApplyFilter(
    TDGFilterType.gftText,
    TDGFilterOperation.foContains,
    '#1');
end;

procedure TForm1.btnFilterNumberColumnClick(Sender: TObject);
begin
  WebDataGrid1.ColumnDefs.FindColumn('NumberColumn').ApplyFilter(
    TDGFilterType.gftNumber,
    TDGFilterOperation.foGreaterThanOrEqual,
    25);
end;

procedure TForm1.btnClearFiltersClick(Sender: TObject);
begin
  WebDataGrid1.ColumnDefs.ClearFilters;
end;

procedure TForm1.btnClearTextColumnClick(Sender: TObject);
begin
  WebDataGrid1.ColumnDefs.FindColumn('TextColumn').ClearFilter;
end;

procedure TForm1.btnClearNumberColumnClick(Sender: TObject);
begin
  WebDataGrid1.ColumnDefs.FindColumn('NumberColumn').ClearFilter;
end;

Pagination

procedure TForm1.WebFormCreate(Sender: TObject);
var
  Data, IStr: String;
  I: Integer;
begin
  Data := '';
  for I := 1 to 300 do
  begin
    IStr := IntToStr(I);
    Data := Data + IStr + ',"Item #' + IStr + '","Item #' + IStr + '"' + #$D#$A;
  end;

  WebDataGrid1.LoadFromCSVString(Data);
  UpdatePagination;
end;

procedure TForm1.UpdatePagination;
begin
  WebDataGrid1.Pagination := true;
  WebDataGrid1.PaginationPageSizeSelector := '20,40,80';
  WebDataGrid1.PaginationPageSize := 40;
end;

Combining the Features

• Editable columns for quick data entry
• Sorting for comparing records
• Filtering for narrowing down large lists
• Pagination for keeping the UI fast and readable

Conclusion

TMS FNC Cloud Pack is well known for its ready-made components to services like Google Drive, Microsoft Outlook Mail. What is often overlooked is that the same package also gives you a lightweight, asynchronous HTTP engine called TTMSFNCCloudBase. With just a few lines of code, this engine lets you talk to any REST API, even when there is no pre-built wrapper available.

In this blog post we will show how easy this is by building a working currency converter from scratch in a short time. Thanks to the FNC framework, the same code runs on VCL, FMX, and TMS WEB Core.

Picking an API

If you are looking for a free API to experiment with, Free Public APIs is a handy curated directory. For this example we picked UniRateAPI, a currency rate service with a generous free tier and a clean REST interface.

Create a free account at unirateapi.com and copy your API key from the dashboard. One detail to keep in mind right away: the API requires a User-Agent header on every request and will return HTTP 403 if it is missing. We will come back to this in step 3.

The Building Block: TTMSFNCCloudBase

For APIs that authenticate with a simple key (rather than OAuth 2.0), TTMSFNCCloudBase is all you need. The workflow is the same every time. You create an instance, populate its Request object with the host, path, query, headers, and HTTP method, and then call ExecuteRequest with a callback procedure. The call returns immediately and the response arrives on the callback, which keeps the UI fully responsive.

Step-by-Step Implementation

1. Create the instance

procedure TForm1.FormCreate(Sender: TObject);
begin
  FCloudService := TTMSFNCCloudBase.Create;
end;

No setup is needed at construction time. The same instance can be reused for any number of subsequent requests.

2. Build the request

The conversion endpoint is GET /api/rates on https://api.unirateapi.com. The required query parameters are api_key, amount, from, to, and format.

FCloudService.Request.Clear;
FCloudService.Request.Name   := 'GET CURRENCY CONVERT';
FCloudService.Request.Host   := 'https://api.unirateapi.com';
FCloudService.Request.Path   := '/api/rates';
FCloudService.Request.Query  := 'api_key='  + TTMSFNCUtils.URLEncode(edAPIKey.Text)
                               + '&amount=' + edAmount.Text
                               + '&from='   + edFrom.Text
                               + '&to='     + edTo.Text
                               + '&format=json';
FCloudService.Request.Method := rmGET;

TTMSFNCUtils.URLEncode (from TMS FNC Core) safely escapes any special characters in the API key.

3. Add the required User-Agent header

As mentioned earlier, UniRateAPI will reject requests without a User-Agent header. Adding one takes a single line:

FCloudService.Request.AddHeader('User-Agent', 'TMSFNCCloudAPIWrapper');

AddHeader can be called repeatedly to attach any number of custom headers. This is useful whenever an API requires bearer tokens, header-based API keys, or vendor-specific values.

4. Execute asynchronously

FCloudService.ExecuteRequest(DoAPIRequestResult);

The call is non-blocking. The UI thread stays free while the HTTP round-trip completes in the background.

5. Handle the response

The callback receives a TTMSFNCCloudBaseRequestResult record that carries the HTTP status code and the raw response body. When the request succeeds, the JSON payload is parsed with TJSONObject.ParseJSONValue, and the relevant numeric values are extracted and assigned to the TLabel controls on the form so the user sees the converted amount and the exchange rate. The JSON object is freed in a try..finally block to avoid memory leaks.

procedure TForm1.DoAPIRequestResult(
  const ARequestResult: TTMSFNCCloudBaseRequestResult);
var
  LJson: TJSONObject;
begin
  if ARequestResult.ResponseCode = 200 then
  begin
    LJson := TJSONObject.ParseJSONValue(ARequestResult.ResultString) as TJSONObject;
    if Assigned(LJson) then
    try
      lbToAmount.Text := FormatFloat('0.00',
        (LJson.GetValue('result') as TJSONNumber).AsDouble);
      lbRate.Text := FormatFloat('0.00',
        (LJson.GetValue('rate') as TJSONNumber).AsDouble);
    finally
      LJson.Free;
    end;
  end;
end;

A successful response looks like this:

{
  "base": "USD",
  "target": "EUR",
  "rate": 0.9187,
  "amount": 100,
  "result": 91.87
}

The result field holds the converted amount and is assigned to lbToAmount, while the rate field holds the exchange rate used and is assigned to lbRate. Both values pass through FormatFloat with the '0.00' mask so they always display with two decimal places. 

6. Clean up

procedure TForm1.FormDestroy(Sender: TObject);
begin
  FCloudService.Free;
end;

Download the complete sample project shown in this post.

Conclusion

With a handful of lines of Delphi code, TMS FNC Cloud Pack gives you access to any REST API. The same TTMSFNCCloudBase class that powers the built-in Google Drive, Microsoft Outlook Mail wrappers is available to you for any service you want to integrate, whether public or in-house. And when an API uses OAuth 2.0 instead of a static key, TTMSFNCCloudOAuth picks up where this example leaves off and handles the full three-step authentication flow for you. 

After more than two decades of life as a closed-source product, the full source code of TMS Data Modeler is now publicly available on GitHub:

github.com/tmssoftware/datamodeler

This post is a quick tour of what the release means, what's in the repo, and why opening it up took more than just flipping a switch. 

Don't forget to start the repository!

A quick refresher on TMS Data Modeler

TMS Data Modeler is a visual database design tool for Windows, written in Delphi.

In a nutshell, it lets you:

• Design databases visually with entity-relationship diagrams
• Generate DDL scripts to create databases
• Generate ALTER scripts to update existing databases between versions
• Reverse-engineer existing databases
• Compare versions and projects
• Archive history and validate models
• Convert models between different database systems

Supported databases: SQL Server, Firebird, Oracle, PostgreSQL, MySQL, and SQLite.

And for TMS Aurelius users — the ORM framework for Delphi — Data Modeler is the most natural way to work in a database-first style: model your schema visually, then generate the Aurelius entity-mapped classes directly from the model.

A bit of history

Data Modeler has been around far longer than its current name suggests:

• Late 1990s / early 2000s — originally developed by a Brazilian company as an internal tool. It wasn't even primarily a modeling tool back then: it was a CRUD form generator, and the database modeling part existed only to feed metadata into the form generation.
• Mid 2000s — acquired by Devgems and rebranded as DevGems Data Modeler.
• Later — acquired by TMS Software and re-released as TMS Data Modeler.

More than twenty years of evolution land in the repository you can now git clone.

Why we're releasing the source

Several motivations led to opening up the source:

• Transparency — customers can read, audit, and trust the code they rely on.
• Flexibility — teams can adapt the tool to specific needs that wouldn't make sense as features in the mainstream product.
• Community contributions — pull requests are welcome, and improvements from the community flow back to all users.
• Ecosystem alignment — it brings Data Modeler in line with the rest of the TMS BIZ products, where source access is the norm.
• Learning — both as a way to understand Data Modeler internals, and as a real-world example of a non-trivial Delphi application built on top of TMS components.

That last point deserves its own section.

A real-world example of TMS components in action

If you've ever wanted to see how TMS components fit together in a serious, production-grade Delphi application, the repository is a good place to read code. Among other things, Data Modeler uses:

• TMS Diagram Studio — powers the entity-relationship diagram editor: the canvas, shapes, connectors, and the whole visual editing experience.
• TMS Scripter — the entire scripting extensibility layer. Users can write scripts that automate tasks against the model, and that fully customize the class-generation output.
• TMS Aurelius — used specifically in the export / code-generation task, to reuse types declared in Aurelius units when emitting entity classes. (Data Modeler does not use Aurelius as its own persistence layer.)
• TMS VCL UI Pack — the entire desktop UI: ribbon, menus, edits, grid, and the rest of the controls that make up the application's look and feel.

Plus a non-TMS dependency: JAM Software Virtual TreeView.

For a Delphi developer evaluating these components, reading how they're wired up in a real product is often more useful than any tutorial.

What it took to get here

Releasing the source of a closed-source product is not just flipping a visibility flag. A closed-source codebase grows under the assumption that nobody else will ever read it — and that assumption shows up in lots of small places.

To get Data Modeler ready for the public, we did a substantial pass over the code:

• Reviewed and sanitized the entire codebase
• Reorganized units into category folders — Model, Connectors, Dialogs, and others. Before the cleanup, every unit lived flat in a single folder
• Broke remaining circular unit references so the structure makes sense as you navigate it
• Translated remaining Portuguese comments and identifiers (leftovers from the tool's origins)
• Removed several third-party dependencies, both to reduce licensing surface and to make ongoing upgrades to newer Delphi versions easier
• Removed the internal license-control machinery — no longer meaningful with the source in the open
• Rebuilt the full CI/CD deployment pipeline

One deliberate non-decision: we did not rename units to follow a stricter naming convention. The folder structure already conveys scope, and renaming hundreds of units would be a lot of churn for very little gain. Over time, individual units may get renamed as we revisit them, but no top-down rename was warranted.

Given all the effort above, this new milestone of source code availability, the removal/refactor of several parts of application (no more licensing tool, splash screen removed, automatic updates disabled, among others), we updated the version number and the current available source code, binary and installers are now released as TMS Data Modeler 4.0

Built with TMS Smart Setup

The repository is fully prepared for TMS Smart Setup, which gives you two convenient flows.

Build from the command line — from the repository root, run:

tms restore tms.snapshot.yaml -skip-register

Smart Setup resolves all third-party dependencies and builds the dm.exe binary.

Set up for development in the IDE — running tms restore from an existing valid Smart Setup folder installs the required components into the IDE, so you can open dm/dm.dproj in Delphi 13 to build, debug, and explore the code interactively.

For end users who simply want to install the tool, the new CI/CD pipeline publishes installer binaries automatically to the GitHub Releases page — no source involved.

A note on licensing

TMS Data Modeler is source-available, not open source. In short:

• Non-commercial use (learning, evaluation, education, open-source projects) does not require a paid license
• Commercial use still requires a paid license, available from the product page
• Contributions are accepted under the terms in the repository's LICENSE.txt

Support continues through the TMS Support Center as before.

Where to go from here

• Repository: github.com/tmssoftware/datamodeler. Give a star to it!
• Product page: tmssoftware.com/site/tmsdm.asp
• Documentation: doc.tmssoftware.com/biz/datamodeler

Clone it, build it, explore the code, file a PR — or just keep using the binary releases. The choice is yours, and that's the point.

Intro

Not every data operation belongs on screen. Sometimes you need to load a data set, filter it, sort it, group it, calculate summaries, and export the result without showing a grid at all.

That is where the headless data layer in TMS FNC Data Grid becomes especially useful. With TTMSFNCDataGridData, the same engine that powers the visual TTMSFNCDataGrid can be used independently in services, background jobs, console tools, tests, batch exports, or startup data preparation routines.

In other words: you can use the grid's data intelligence without needing the grid's visual surface.

Why Use a Headless Data Layer?

A visual grid is perfect when users need to inspect and interact with data. But many application workflows happen before, after, or completely outside the UI:

• Background processing: load data, transform it, and prepare results while the UI remains responsive

• Batch exports: generate filtered CSV files without creating a form or control

• Automated tests: verify sorting, filtering, grouping, and aggregation logic without UI automation

• Services and console apps: reuse familiar grid data operations in non-visual applications

The important part is that TTMSFNCDataGridData owns the data operations. Methods such as Filter.Add, ApplyFilter, Sort, Group, SaveToCSVData, and the typed accessors like Strings[], Floats[], and Ints[] are available directly on the data layer.

Creating the Data Object

Because TTMSFNCDataGridData is a regular Delphi object, it can be created anywhere you would normally create an object. There is no need for a form, parent control, or rendering context.

type
  TMyForm = class(TForm)
  private
    FData: TTMSFNCDataGridData;
  end;

procedure TMyForm.FormCreate(Sender: TObject);
begin
  FData := TTMSFNCDataGridData.Create;
end;

procedure TMyForm.FormDestroy(Sender: TObject);
begin
  FData.Free;
end;

That small setup gives you a reusable in-memory data layer with the same core operations you would expect from the visual grid.

Loading Data

The headless layer supports the same practical loading scenarios as the grid. You can load JSON, load CSV, or fill cells manually when you want full control.

// From JSON
FData.Options.IO.StartRow := 1;
FData.LoadFromJSONData(
  JSONPath,
  '', '',
  ['id', 'name', 'category', 'price', 'stock', 'is_organic', 'is_vegan']);

// From CSV
FData.LoadFromCSVData('products.csv', ',');

Setting Options.IO.StartRow to 1 before loading JSON is a useful detail: row 0 can receive the JSON key names as column headers, while the actual records start below that fixed header row.

Manual population is equally direct:

FData.ColumnCount   := 3;
FData.FixedRowCount := 1;
FData.RowCount      := 4;

FData.Cells[0, 0] := 'ID';
FData.Cells[1, 0] := 'Name';
FData.Cells[2, 0] := 'Price';

FData.Cells[0, 1] := 1;
FData.Cells[1, 1] := 'Widget A';
FData.Cells[2, 1] := 9.99;

Filtering Without a Grid

Filtering works the same way it does with the visual grid. Add one or more filter conditions, apply them, and then work with the displayed rows.

FData.Filter.Clear;
FData.Filter.Add(COL_CATEGORY, gftEqual, 'Meat');
FData.ApplyFilter;

After calling ApplyFilter, rows that do not match are hidden from the active view. You can use IsRowDisplayed when iterating the data:

var Count := 0;

for var R := FData.FixedRowCount to FData.RowCount - 1 do
  if FData.IsRowDisplayed(R) then
    Inc(Count);

Log(Format('%d matching rows', [Count]));

To return to the full data set, call RemoveFilter.

FData.RemoveFilter;

Sorting the Active Result

Sorting is just as compact. The data layer can sort a column in ascending or descending order without requiring any visual repaint cycle.

FData.Sort(COL_PRICE, gsdDescending);

Sorting and filtering work together. When a filter is active, the sort operation reorders the displayed rows while keeping filtered-out rows hidden.

Grouping and Aggregations

The headless layer is also useful when you need summary data. You can group by a column and calculate values such as count, sum, average, minimum, or maximum.

FData.Group(COL_CATEGORY);
FData.GroupCount(COL_CATEGORY);
FData.GroupSum(COL_PRICE);

Once grouped, the result contains group header rows and summary rows that can be inspected programmatically:

for var R := FData.FixedRowCount to FData.RowCount - 1 do
begin
  if FData.IsRowNode(R) then
    Log(FData.Strings[FData.FixedColumnCount, R])
  else if FData.IsRowSummary(R) then
    Log(Format('  count=%.0f   sum=$%.2f',
      [FData.Floats[COL_CATEGORY, R], FData.Floats[COL_PRICE, R]]));
end;

FData.Ungroup;

This makes it convenient to build reporting features where the final output is a log, CSV file, dashboard feed, or another data structure rather than an interactive grid.

Exporting the Result

After loading, filtering, sorting, and grouping, you can export the processed result directly to CSV.

FData.SaveToCSVData('output.csv', ',');

This is a practical pattern for server-side export buttons, scheduled reporting tasks, or command-line tools that need the same data behavior as your application's UI.

Reading Typed Values

When looping over rows, use the typed accessors to keep your code clear and efficient. Instead of reading everything as text and converting manually, read the expected data type directly from the layer.

var Name  := FData.Strings[COL_NAME,  Row];
var Price := FData.Floats [COL_PRICE, Row];
var Stock := FData.Ints   [COL_STOCK, Row];

For tight processing loops, this keeps the intent of the code obvious: names are strings, prices are floating point values, stock counts are integers.

Showing the Data Later

Using the headless layer does not lock you into a non-visual workflow. If the processed data later needs to be shown in a TTMSFNCDataGrid, you can load the same source into the grid or copy values into the visual component.

// Let the grid load its own visual copy
TMSFNCDataGrid1.LoadFromJSONData(
  JSONPath,
  '', '',
  ['id', 'name', 'price']);

For database-backed scenarios, TTMSFNCDataGridDatabaseAdapter can be used with a shared TDataSet. You can bind that adapter to a visual grid, or bind it directly to TTMSFNCDataGridData when the workflow is headless and the data operations matter more than immediate visual interaction.

Binding a Dataset

For a non-visual workflow, assign the database adapter to the data layer. The result is still a dataset-backed data engine, but without any renderer or control on screen.

procedure TMyService.LoadProducts;
begin
  FData := TTMSFNCDataGridData.Create;

  Adapter.DataSource := DataSource1;     // TDataSource attached to FDQuery1
  Adapter.AutoCreateColumns := True;

  FData.Adapter := Adapter;

  FDQuery1.Open;                         // records are loaded into FData

  FData.Filter.Clear;
  FData.Filter.Add(COL_CATEGORY, gftEqual, 'Meat');
  FData.ApplyFilter;

  FData.Sort(COL_PRICE, gsdDescending);
  FData.SaveToCSVData('filtered-products.csv', ',');
end;

This is the database equivalent of loading JSON or CSV into FData: once the records are in the data layer, the rest of the processing code can stay the same. For exports, reports, validation jobs, and tests, that can be cleaner than creating a visual grid just to reach the data operations.

Choosing Fields and Column Behavior

Automatic columns are convenient during prototyping, but production screens often need a more curated shape: hide technical fields, reorder columns, use friendly headers, or render specific field types with richer UI.

The adapter column collection lets you decide exactly which fields appear and how they are presented:

Adapter.AutoCreateColumns := False;

with Adapter.Columns.Add do
begin
  FieldName := 'ProductName';
  Header := 'Product';
end;

with Adapter.Columns.Add do
begin
  FieldName := 'Price';
  Header := 'Unit Price';
end;

Individual adapter columns can also be configured for more specialized rendering:

Adapter.Columns[2].HTMLTemplate    := '<b>{Name}</b>';
Adapter.Columns[3].PictureField    := True;   // BLOB field as image
Adapter.Columns[4].ProgressField   := True;   // numeric field as progress bar
Adapter.Columns[5].UseLookupEditor := True;   // lookup field as drop-down

For conversion logic, the adapter exposes OnFieldToData and OnDataToField. That gives you a clean place to format database values before they enter the grid, or to translate edited grid values before they are posted back to the dataset.

A Complete Processing Flow

A typical headless workflow can be surprisingly small: load records, apply business filters, sort the result, and export it.

FData.ClearData;
FData.FixedRowCount       := 1;
FData.Options.IO.StartRow := 1;

FData.LoadFromJSONData(
  JSONPath,
  '', '',
  ['id', 'name', 'category', 'price', 'stock']);

FData.Filter.Clear;
FData.Filter.Add(COL_CATEGORY, gftEqual, 'Meat');
FData.ApplyFilter;

FData.Sort(COL_PRICE, gsdDescending);
FData.SaveToCSVData('filtered-products.csv', ',');

No visual control is required, but the data behavior remains consistent with the grid users see elsewhere in the application.

Sample

https://www.tmssoftware.com/download/DataLayerDemo.zip

Conclusion

TTMSFNCDataGridData gives you the data-processing side of TTMSFNCDataGrid as a standalone layer. You can load JSON or CSV, apply filters, sort rows, group data, calculate aggregations, read typed values, and export the result without placing a grid on screen.

For applications that need background exports, automated tests, reporting pipelines, or non-visual data preparation, this is a clean way to reuse the same proven data layer that powers the visual grid. It keeps your logic testable, your UI optional, and your data workflow ready for both desktop and web applications.

Introduction

procedure TForm2.InitGrid;
begin
  WebDataGrid1.Clear;
  WebDataGrid1.ColumnDefs.Clear;

  WebDataGrid1.ColumnDefs.Add;
  WebDataGrid1.ColumnDefs.Add;
  WebDataGrid1.ColumnDefs.Add;
  WebDataGrid1.ColumnDefs.Add;

  WebDataGrid1.ColumnDefs[0].HeaderName := 'Product';
  WebDataGrid1.ColumnDefs[0].EditModeType := cetCombobox;
  WebDataGrid1.ColumnDefs[0].Editable := true;
  WebDataGrid1.ColumnDefs[0].Field := 'Product'; 
  ....
end;

var
  dgs: TDGSelectCellEditorCollectionItem;

  begin
    dgs := WebDataGrid1.ColumnDefs[0].SelectOptions.Add;
    dgs.Value := 'Delphi';
    dgs := WebDataGrid1.ColumnDefs[0].SelectOptions.Add;
    dgs.Value := 'C++Builder';
    ....
  end;

procedure TForm2.Recalc(RowIndex: integer);
var
  q,p: integer;
begin
  p := integer(WebDataGrid1.CellByName[RowIndex, 'Price']);
  q := integer(WebDataGrid1.CellByName[RowIndex, 'Quantity']);
  WebDataGrid1.CellByName[RowIndex, 'Total'] := p * q;
end;

procedure TForm2.WebButton1Click(Sender: TObject);
begin
  WebDataGrid1.InsertNewRow;
  WebDataGrid1.CellByName[WebDataGrid1.RowCount - 1, 'Product'] := 'Delphi';
  WebDataGrid1.CellByName[WebDataGrid1.RowCount - 1, 'Quantity'] := 0;
  WebDataGrid1.CellByName[WebDataGrid1.RowCount - 1, 'Price'] := 123;
end;

procedure TForm2.WebButton2Click(Sender: TObject);
begin
  WebDataGrid1.Clear;
  WebDataGrid1.ColumnDefs.Clear;

  WebDataGrid1.ColumnDefs.Add.Field := 'Brand';
  WebDataGrid1.ColumnDefs.Add.Field := 'Model';
  WebDataGrid1.ColumnDefs.Add.Field := 'Type';

  WebDataGrid1.LoadFromJSON(
    'https://download.tmssoftware.com/tmsweb/demos/' +
    'TMSWEB_ResponsiveGrid/carsfull.json');
end;

procedure TForm2.DGCustomDataAdapter1GetRows(Params: TJSGetRowsParams);
var
  I: Integer;
  RowData: TJSArray;
begin
  RowData := TJSArray._of;

  for I := Params.StartRow to Params.EndRow do
  begin
    RowData.push(new([
      'Id', I + 1,
      'Data', 'Row Number ' + IntToStr(I)
    ]));
  end;

  DGCustomDataAdapter1.GetRowsSuccessful(
    RowData,
    10000,
    Params);
end;

procedure TForm2.WebButton1Click(Sender: TObject);
begin
  WebStellarDataStoreClientDataset1.Active := true;
end;

We are pleased to announce the release of TMS Dashboard v1.4.0.0. TMS Dashboard is a free utility for TMS Software customers that provides a central hub for managing your TMS component installations, monitoring available updates, and keeping your Delphi development environment in sync. This update delivers compatibility with the latest TMS Smart Setup v3.3 and brings an improved, reorganized options dialog for a more streamlined configuration experience.

What's new in v1.4.0.0

TMS Smart Setup v3.3 compatibility

TMS Dashboard v1.4.0.0 adds compatibility with TMS Smart Setup v3.3. Since TMS Smart Setup uses an auto-update system, you are always running the latest version automatically. This update ensures TMS Dashboard stays in sync with those automatic upgrades.

For a full overview of what's new in the TMS Smart Setup 3.x series, please refer to the dedicated blog post:

Announcing SmartSetup 3.0… and 3.1… and 3.2… and 3.3!

Reorganized options dialog

The TMS Dashboard Options dialog has been reorganized for clarity. Settings are now grouped more logically across the sidebar navigation, making it easier to find and configure exactly what you need.

The sidebar navigation now clearly separates the key areas: My Account, TMS Smart Setup, Delphi Versions, Notifications, Status, and About. The My Account section displays a live validation indicator, confirming at a glance whether your email address and registration code are valid. The TMS Smart Setup section indicates if the TMS Smart Setup executable was detected correctly in the provided path.

Getting the update

TMS Dashboard v1.4.0.0 is available now. The update can be downloaded directly via the built-in update link in TMS Dashboard, or from the TMS Dashboard product page.

Why TWebDBDataGrid?

Delphi-style databinding for web client applications

WebDBDataGrid1.DataSource := WebDataSource1;
WebDataSource1.DataSet := WebClientDataSet1;

TWebClientDataSet
TXDataDataSet
TStellarDataStoreClientDataSet

Less glue code, more productivity

• displaying dataset records
• editing data
• sorting
• formatting
• paging
• filtering

procedure TForm1.WebFormCreate(Sender: TObject);
begin
  WebDataSource1.DataSet := WebClientDataSet1;
  WebDBDataGrid1.DataSource := WebDataSource1;
  WebClientDataSet1.Open;
end;

procedure TForm1.WebFormCreate(Sender: TObject);
begin
  WebDataSource1.DataSet := XDataDataSet1;
  WebDBDataGrid1.DataSource := WebDataSource1;
  XDataDataSet1.Open;
end;

procedure TForm1.WebFormCreate(Sender: TObject);
begin
  WebDataSource1.DataSet := StellarDataStoreClientDataSet1;
  WebDBDataGrid1.DataSource := WebDataSource1;
  StellarDataStoreClientDataSet1.Open;
end;

Editing data in the browser

procedure TForm1.btnSaveClick(Sender: TObject);
begin
  if WebDataSource1.DataSet.State in dsEditModes then
    WebDataSource1.DataSet.Post;
end;

procedure TForm1.btnCancelClick(Sender: TObject);
begin
  if WebDataSource1.DataSet.State in dsEditModes then
    WebDataSource1.DataSet.Cancel;
end;

A natural fit for database-backed web applications

• admin dashboards
• ERP-style browser applications
• customer portals
• order management systems
• reporting screens
• planning tools
• database maintenance applications

Built-in power of TWebDataGrid

• column formatting
• sorting
• filtering
• paging & continuous data loading during scroll
• editing with multiple editor types
• custom cell content
• responsive browser rendering
• large data presentation

Conclusion

Beta available now

Time flies when you are having fun. We have been so busy lately adding new stuff to SmartSetup that we haven't had enough time to tell you about everything that's new. So, in this post, we wanted to give you a recap of the main new features.

Versioning

In SmartSetup 3.0 we added versioning. This means that you can now install older versions of our components (and components from the community server) just by right-clicking them in tmsgui and selecting a version.

Because SmartSetup was designed from the start to support versioning, this change is retroactive across all versions of TMS components ever published with SmartSetup. So even though we only released versioning support a month ago, you can get a component from a year ago without issues.

For open-source components in Git, you can get any tagged version in the repository (shown here in dark mode, so we can also show off another great feature in SmartSetup 3.0):

This is, of course, also supported from the command line.

Note: versioning is not yet supported in tms dashboard. Until that support is added, you'll need tmsgui or tms directly to work with older versions.

Besides adding the much-requested support for older versions, SmartSetup 3.0 added the following features to make it simpler to work with versions:

• Snapshots: These work like a lock file in other package managers. They let you record the exact components and versions you are using at any given moment. You can generate snapshots automatically and store them in git, so if you want to roll a project back a year — including the component versions you were using then — you can simply restore the snapshot saved at that time. Snapshots also make it easy to reproduce the same environment across multiple machines.
• Version Pinning: You can now pin individual components, so they don't update automatically when you run an update. You can also pin all components, if you want to be sure nothing updates until you manually unpin them. As usual, this works with both TMS and non-TMS components. If you look back at the images at the beginning of this post, you can see that tms.fnc.uipack is pinned, in the leftmost column of the grid.
• MultIDE: There is a new tool available at https://github.com/agallero/multide that makes it simpler to have multiple versions of components installed on the same machine at the same time. I personally use it a lot to test different setups for customers.

Windows on ARM Support

In version 3.1, SmartSetup added support for the new Windows on ARM platform, just days after it was introduced in RAD Studio. We did find the time to write about that one, so for more information see https://www.tmssoftware.com/site/blog.asp?post=2468

SBOM

Version 3.2 added a sbom-generate command that can produce a CycloneDX SBOM for every installed component, using the knowledge SmartSetup already has about dependencies and versions. The idea is not to replace an application-wide SBOM tool, but to feed it accurate component-level information that the app can use to generate the bigger SBOM for your application. If you are doing a SBOM application and think you can use the information SmartSetup can generate, do not hesitate to contact us.

SBOM is still a moving target, so expect changes in this area as the exact requirements become clearer. We plan to blog about more specific SBOM stuff in the future.

We would like to specially thank Björn Mänken for contributing the SBOM-generating code.

Automated Builds

In release 3.3 we added many improvements for running automated builds on a server, along with a document with information about how to set it up. SmartSetup was originally created as a builder, and we have been using it that way for years. Fun fact: the original command-line project was called "tmsbuild", as a word play on "msbuild". When we added more commands, we renamed it to "tms" to avoid having to type "tmsbuild build" — so you can still write "tms build", just with an extra space. But from the beginning, SmartSetup has been a builder, as you can infer from its original name.

In 3.3 we documented a lot more on how SmartSetup can be used to build your projects, not just install components. We also fixed many small things and added quality-of-life features to make the process smoother. We hope it helps speed up your build systems as much as it has ours. For complex projects, the parallel compilation in SmartSetup can shave literal hours off build times. In my own case, a build of FlexCel (the components themselves, plus more than 60 demos, tools, etc., built for Delphi XE through Delphi 13 on every platform) used to take about 8 hours. The new SmartSetup-based builder does the same work in 45 minutes. The speed gains are real.

And a lot more

You can find a full list of the smaller changes at https://doc.tmssoftware.com/smartsetup/guide/release-notes.html. Things like much-improved installs in Delphi Community Edition, or credentials now being stored securely in the Windows Credential Manager. From an improved tms doctor that can find and fix more misconfigurations, to a new tms spec command that makes creating SmartSetup spec files much easier. From a new Dark Mode in tmsgui to greatly improved documentation. And so on.

Finally, let us once more remind you that SmartSetup is fully open source, and you can find the repository at https://github.com/tmssoftware/smartsetup. Feel free to open issues if you run into trouble or are missing functionality. All contributions are welcome, from improving the docs to bug fixes and new features. And if you find SmartSetup as useful as we do, don't forget to give it a star! Help us make SmartSetup great for the whole Delphi community.

Intro

Stock data is one of the most demanding chart scenarios: dense OHLC bars, date labels that need rotating, interactive panning across months of history, and overlay series like trend lines and moving averages sitting on top. This post shows how TMS FNC Chart handles all of it with a real NVIDIA price history dataset — loading straight from CSV, switching between OHLC and line views, and adding a trend line and 30-day moving average in a few lines of code.

Watch The Video

Watch the companion walkthrough on YouTube:

Quick Highlights

• LoadFromCSVMultiPointData maps CSV columns to Open, High, Low, and Close in a single call — no manual parsing.

• LoadFromCSVData pulls just the Close column for the line view, and AddTrendLine / AddMovingAverage add overlays over the same data immediately after.

• Horizontal panning and zoom are enabled with three properties, and a point-based crosshair snaps to the nearest bar automatically.

• The BeforeDrawSerieXValue event suppresses out-of-range date labels that appear when the scroll window extends past the data.

Loading OHLC Data from CSV

The CSV has five columns: Date, Open, High, Low, Close. LoadFromCSVMultiPointData takes the file path, a load options object, and then the column index for each OHLC field followed by the label column. Setting CSVFirstLine := cflFirstLineSkip discards the header row automatically.

lo := TTMSFNCChartLoadOptions.Create;
lo.CSVDelimiter := ',';
lo.CSVFirstLine := cflFirstLineSkip;

TMSFNCChart1.LoadFromCSVMultiPointData(STOCKDATAFILE, lo,
  2,   // Open
  3,   // High
  1,   // Low
  4,   // Close
  -1, -1,
  0);  // Label (Date)

TMSFNCChart1.Series[0].ChartType := ctOHLC;

After the load, setting ChartType := ctOHLC is the only change needed to render the bars. The same call works for ctCandleStick if you prefer filled bodies.

Interaction: Panning and Zoom

Six months of daily bars is too much to read at full width. Three properties turn on horizontal-only scaling and panning, and MinX / MaxX set the initial visible window to the full dataset so the scroll range is correct from the start.

TMSFNCChart1.Interaction := True;
TMSFNCChart1.InteractionOptions.ScaleMode := smHorizontal;
TMSFNCChart1.InteractionOptions.Panning   := True;

TMSFNCChart1.Series[0].AutoXRange := arDisabled;
TMSFNCChart1.Series[0].MinX := 0;
TMSFNCChart1.Series[0].MaxX := TMSFNCChart1.Series[0].Points.Count - 1;

A point-based crosshair snaps to the nearest bar on hover, showing the exact OHLC values without the crosshair drifting between bars.

TMSFNCChart1.Crosshair.Visible := True;
TMSFNCChart1.Crosshair.Modes   := [ccmPointBased];

Highlight: smHorizontal locks vertical scale while panning, which is exactly what you want for stock charts — the Y axis stays fixed to the full price range while you scroll through time.

Line View: Trend Line and Moving Average

The second button reloads the same CSV using LoadFromCSVData, pulling only the Close column. AddTrendLine and AddMovingAverage are then called over the full point range and each returns a TTMSFNCChartSerie that can be styled like any other series.

TMSFNCChart1.LoadFromCSVData(STOCKDATAFILE, lo, [4], -1, 0);

TMSFNCChart1.AddTrendLine(0, 0, TMSFNCChart1.Series[0].Points.Count - 1);
TMSFNCChart1.AddMovingAverage(0, 0, TMSFNCChart1.Series[0].Points.Count - 1, 30);

TMSFNCChart1.Series[1].Stroke.Color := gcRed;
TMSFNCChart1.Series[1].Stroke.Width := 3;

TMSFNCChart1.Series[2].Stroke.Color := gcBlue;
TMSFNCChart1.Series[2].Stroke.Width := 3;

The trend line (series index 1) is drawn in red, and the 30-day moving average (series index 2) in blue. Both get AutoXRange := arDisabled and matching MinX / MaxX so they align correctly with the price series during pan and zoom.

Highlight: AddTrendLine and AddMovingAverage append new series to the chart and return them directly. No separate component, no manual calculation — just style the result and move on.

Suppressing Out-of-Range X Labels

When AutoXRange is disabled and the chart draws axis labels beyond the data range, labels with invalid indices appear. The BeforeDrawSerieXValue event catches them before they render.

procedure TForm1.TMSFNCChart1BeforeDrawSerieXValue(Sender: TObject;
  AGraphics: TTMSFNCGraphics; ASerie: TTMSFNCChartSerie;
  APosition: TTMSFNCChartXAxisPosition;
  var ADrawValue: TTMSFNCChartDrawXYValue; var ADefaultDraw: Boolean);
begin
  if ADrawValue.Value < 0 then
    ADefaultDraw := False;

  if ADrawValue.Value >= ASerie.Points.Count then
    ADefaultDraw := False;
end;

Setting ADefaultDraw := False skips the draw for that tick entirely, leaving the axis clean at both ends of the scroll range.

Conclusion

TMS FNC Chart reduces a real-world stock charting scenario to straightforward Delphi code: one call to load OHLC data from CSV, three properties for interactive panning, and two calls to add trend and moving average overlays. The same series model and the same MinX / MaxX scroll pattern apply across both chart types, so switching between the OHLC view and the close-price line view is a matter of reloading the data rather than rebuilding the chart.