It's always a privilege and honour to be able to work with very smart people who are not only expert in Delphi but also expert in a specific domain. Earlier this year, Bernard Roussely and Marion Candau joined tmssoftware.com and focus so far on advanced cryptography algorithms with the highest security levels in TMS Cryptography Pack. More tools that will use this underlying strong technology are already in the pipeline. Around the same time, also Roman Yankovsky joined tmssoftware.com and the static code analysis tool TMS FixInsight is the result. With TMS FixInsight, you can bring your Delphi code to a higher quality & safer level with numerous code hints and suggestions it gives.
Today, I'm proud to announce Sergey Gladkiy joins the TMS team for working on products with a strong mathematical background. The first result is the TMS Analytics & Physics Pack. This pack offers a set of (non-visual) platform independent classes to work with mathematical expressions and units of measurements. In TMS Analytics & Physics Pack, you can do evaluation of complex multiparameter mathematical expressions, including expressions with complex numbers. You can do physical measurement conversions of all kinds. But perhaps the most amazing part is symbolic derivative calculations. In this respect, TMS Analytics & Physics Pack brings a math wizard in the form of classes that can be used in VCL and FMX apps. You can discover the power of this library via the included demo but I wanted to share some examples of symbolic derivative calculations that will boggle your mind:

Task: calculate the derivative function of:
1/(x-1)+(2*x-1)/(x+1)^2

Result:
(-(1)/(x-1)^2)+(2*(x+1)^2-(2*(x+1)^(2-1))*(2*x-1))/((x+1)^2)^2

The code to achieve this is as simple as:

var
   f,df: string;

   f := '1/(x-1)+(2*x-1)/(x+1)^2';

   try
      if Translator.CheckSyntax(f) then
      begin
        df:=Translator.Derivative(f,'x');
        ShowMessage('Derivative function :' + df);
      end;
   except
      ShowMessage('Error');
   end;

var
   df: string;
   v: TValue;

   df := '((cos(x)+(-sin(x)))*x-(sin(x)+cos(x)))/x^2';

   try
      Translater.Add('x', 2.0); 
      if Translator.CheckSyntax(df) then
      begin
        v :=Translator.Calculate(df);
        ShowMessage('Result :' + s:=TUtilities.SafeToString(v));
      end;
   except
      ShowMessage('Error');
   end;

What's wrong with the KIS principle to store application settings in an INI file? The risk that someone is tampering with the INI file is an often heard reason for not using them. Not being able to store private or secret information another one.
Both issues are solved with the introduced TEncryptedIniFile class. It descends from TMemIniFile and is as such a drop-in replacement and will deal only in app memory with decrypted data. In the file itself, the data is at all times encrypted. To build TEncryptedIniFile, we internally use AES 256bit encryption offered by the TAESEncryption class in TMS Cryptography Pack.

The code to use TEncryptedIniFile becomes something like:

const
  aeskey = 'anijd54dee1c3e87e1de1d6e4d4e1de3';
var
  mi: TEncryptedIniFile;
begin
  try
    mi := TEncryptedIniFile.Create('.settings.cfg', aeskey);
    try
      FTPUserNameEdit.Text := mi.ReadString('FTP','USER','');
      FTPPasswordNameEdit.Text := mi.ReadString('FTP','PWD','');
      FTPPortSpin.Value := mi.ReadInteger('FTP','PORT',21);
      mi.WriteDateTime('SETTINGS','LASTUSE',Now);
      mi.UpdateFile;
   finally
      mi.Free;
   end;
  except
    ShowMessage('Error in encrypted file. Someone tampered with the file?');
  end;
end;

During CodeRage XI, the online event from Embarcadero, Bruno Fierens (founder TMS software and Embarcadero MVP), Wagner Landgraf (TMS Business product manager) & Roman Yankovsky (TMS FixInsight product manager and Embarcadero MVP) brought sessions covering our latest technologies FNC, myCloudData, Aurelius, FixInsight developed at TMS software.

If you missed one of these sessions, you can now watch them via our Youtube channel.

New video's published at tmssoftwareTV:
Cross Framework UI Controls - by Bruno Fierens: This session explains the differences between the VCL and FMX framework that are relevant for custom user interface control development. Given these differences, an abstraction layer, FNC is presented that enables creating custom user interface controls starting from a single source code base that can be used for both VCL, FMX (and LCL) applications. In the last part of the session, several complex FNC UI controls that are in the TMS FNC UI Pack product are demonstrated that can be used in VCL, FMX, LCL applications and target this way Windows, iOS, Android, macOS and Linux.



Metadata assisted automatic DB form generation for cloud data - by Bruno Fierens: The myCloudData.net service offers easy to use structured cloud data storage. The foundation of the service is a REST API. For our Delphi users, we added several components to consume this service with an absolute minimum amount of effort. The TAdvmyCloudData component enables using object oriented programming techniques for using the myCloudData.net service. With TAdvmyCloudDataDataSet and TAdvmyCloudDataDataConnection, controls can be bound directly to the data in the cloud, be it via DB-aware controls or livebindings. For the next level of automation: bound DB forms auto generated with the help of rich metadata, two components are available, TAdvmyCloudDataFormPanel and TAdvmyCloudDataFormBox.



TMS Aurelius Free Edition, an overview - by Wagner Landgraf: An overview of the well-regarded Aurelius ORM framework for Delphi, which now has a free edition for commercial use, available for Delphi 10.1 Berlin.



FixInsight: Finding Bugs with Static Code Analysis - by Roman Yankovsky: Roman Yankovsky shows you how to use FixInsight's static code analysis in Delphi to find bugs in your code before your customers do. Roman Yankovsky is an Embarcadero MVP and the author of FixInsight static analysis tool for Delphi.

After the release of TMS Aurelius Free Edition, the free version of our ORM framework, I've been thinking to do some blog posts about some key TMS Aurelius features. However I spent some time deciding what features to show: would they be in chronological order? Separated by categories? In order of "importance" - and what would be the criteria of "importance"?

Well, finally, as you can tell from the title of this post, I decided to do that in a "top 10 list" format - who knows, maybe this series will appear at Buzzfeed... But most important of all: this is my personal list of favorite features. So no objective criteria here - just some features I consider cool, features that I have "respect" for because were hard to implement or simply features that I use a lot.

So let's go for the list. Starting with #10, I will keep adding new blog posts over time until I reach feature #1. Hope you enjoy it:

#10 - Automapping
#9 - Plain Old Delphi Objects
#8 - Lazy Loading

This is the #10 feature of My Top 10 Aurelius Features. Follow the link for the full list!

Using the automapping feature is easy: you just need to add the [Automapping] attribute to your class:

type
  [Entity, Automapping]
  TCustomer = class
  private
    FId: Integer;
    FName: string;
  public
    property Id: Integer read FId write FId;
    property Name: string read FName write Name;
  end;

type
  [Entity, Automapping]
  TCustomer = class
  private
    FId: Integer;
    [Column('CUSTOMER_NAME', [TColumnProp.Required], 120)]
    FName: string;
  public
    property Id: Integer read FId write FId;
    property Name: string read FName write Name;
  end;

Mathematics is fascinating, Delphi is cool, cross-platform is awesome, cross-framework is the icing on the cake. So, what's better than spending some time with all four on a weekend day?

For some time, we offer our TMS Analytics & Physics package that can do formula evaluation, complex number calculation and most interestingly also expression based derivative function calculation. Also since beginning of 2016, we offer our TMS FNC Chart, which is a chart package that offers a chart UI component that can be used in VCL applications, FMX applications and also LCL (Lazarus/FPC based) applications. This means that with the TMS FNC Chart, we can target Win32, Win64, macOS, iOS, Android, Linux, Raspbian operating systems.

So, I set out this weekend to spend some time creating a simple mathematical formula plotting application (cross platform & cross framework) that could not only display a function but also calculate its derivative function and plot it. This way, we can visually see the effect of calculating a derivative function.
The setup of this application turns out to be amazingly simple with some help of TMS FNC Chart and TMS Analytics & Physics Pack.

The core code is a model class that does chart initialization & formula calculation + derivative calculation by means of two class methods. This model can be used by the VCL, FMX or LCL application as apart from unit references, all code is framework independent. In this model, calculation is central and is nothing more than performing parsing of a mathematical formula and calculating it's derivative and Y-values for a range of X-values and display this in a chart. To do this, we initialize the TTranslator class (part of TMS Analytics) and specify the X is the main variable of the functions we can write and then we check the syntax, calculate the derivative and calculate values for both function and derivative function:

  FTransMain := TTranslator.Create;
  FTransDeriv :=  TTranslator.Create;

  vName := 'x';
  vValue := 1.0;
  FTransMain.Add(vName, vValue);
  FTransDeriv.Add(vName, vValue);

  try
    if FTransMain.CheckSyntax(f) then
    begin
      df := FTransMain.Derivative(f,'x');

      if FTransDeriv.CheckSyntax(df) then
      begin
        for i := -xrange to +xrange do
        begin
          // get Y value of the function for a given X value
          FTransMain.Variables['x'].Value := i;
          v := FTransMain.Calculate(f);
          // add the Y point to the XY chart series 1
          AChart.Series[0].AddXYPoint(i,v.AsExtended);

          // get Y value of the derivative function for a given X value
          FTransDeriv.Variables['x'].Value := i;
          v := FTransDeriv.Calculate(df);
          // add the Y point to the XY chart series 2
          AChart.Series[1].AddXYPoint(i,v.AsExtended);
        end;
      end;
    end;
  finally
    FTransMain.Free;
    FTransDeriv.Free;
  end;

My number 9 feature of My Top 10 Aurelius Features refers to PODO - Plain Old Delphi Objects. Or in other words, the fact that Aurelius entities are simple, clean Delphi classes.

When Aurelius project started back in mid 2011, there were some object persistent frameworks available for Delphi. At that time I was wondering why such existing ones did not catch up strongly.

There were some people using it, but I didn't feel it was something that people were embracing. And one of the reasons (in my opinion) was that to make classes to become persistent the developer needed to do some many workarounds that the class end up being cluttered with unneeded things, and coding with that class was not very pleasant.

Imagine writing business code with the class below:

type
  TContact = class(TORMBaseClass)
  private
    FId: TORMInteger;
    FName: TORMString;
    FCountry: TORMRelationship;
    function GetId: TORMInteger;
    procedure SetId(const Value: TORMInteger);
    function GetName: TORMString;
    procedure SetName(const Value: TORMName);
    function GetCountry: TORMRelationship;
    procedure SetCountry(const Value: TORMRelationship;
  public
    constructor Create(SpecificParams: TORMINit); override;
    destructor Destroy;
    procedure Save(Context: TORMContext); override;
    procedure Update(Context: TORMContext); override;
    procedure Delete(Context: TORMContext); override;
  published
    property Id: TORMInteger read GetId write SetId;
    property Name: TORMString read GetName write SetName;
    property Country: TORMRelationship read GetCountry write SetCountry;
  end;

type
  TContact = class
  private
    FId: integer;
    FName: string;
    FCountry: TCountry;
  public
    property Id: integer read FId write FId;
    property Name: string read FName write FName;
    property Country: TCountry read FCountry write FCountry;
  end;

We are very excited to announce the launch of our new open-source myCloudData.net REST client for Delphi & C++Builder. The myCloudData REST Client is completely free and open-source and hosted on Github, this means that you can freely use or customize the code for your commercial or hobby projects.

Our goal was to provide you with an easy way of using the myCloudData.net service in all your applications, without having to worry about all the difficulties that come with integrating with a complex REST service.

The myCloudData REST Client takes care of handling the HTTP requests, the parsing of the JSON responses and the OAUTH2 authentication. All you have to do is drag the component on to your form and you can start using your cloud databases as they were local databases.

The library is developed from the ground up and is based on the REST technology that is included in RAD Studio 10.1 Berlin. It can be used with your Delphi, C++Builder, RAD Studio 10.1 Berlin IDE as-is, no need to install extra commercial libraries. There is a REST client for VCL applications (for Win32/Win64) and FMX applications (for Win32/Win64/iOS/macOS/Android)

To get you started, here are some highlights of commonly used patterns in consuming structured cloud data storage via myCloudData.net.

Some simple code examples

Creating a table

var 
LContactsTable : TmyCloudDataTable;
begin
    // Search for an existing table
    LContactsTable := MyCloudData.Tables.GetTableByName('MyApplication_Contacts');

    if LTableName = nil then
    begin
        // Create the table
        LContactsTable := MyCloudData.Tables.CreateTable('MyApplication_Contacts');

        // Start adding your fields:
        LContactsTable.Fields.Add('ID', ftInteger);
        LContactsTable.Fields.Add('Name', ftWideString, 30);
        LContactsTable.Fields.Add('EmailAddress', ftWideString, 50);
        LContactsTable.Fields.Add('CountryCode', ftWideString, 2);

        // Save the fields to the myCloudData.net service
        LContactsTable.Fields.Save();
    end;

    // You can start working with the table here.

end;

Working with the entities

var
LContact : TmyCloudDataEntity;
begin
    // Create the new entity on the table
    LContact := LContactsTable.Entities.CreateEntity();

    // Populate the fields on the entity
    LContact.SetValue('ID', 285);
    LContact.SetValue('Name', 'John Doe');
    LContact.SetValue('EmailAddress', 'johndoe@gmail.com');
    LContact.SetValue('CountryCode', 'USA');

    // Save the entity to the myCloudData.net service
    LContactsTable.Entities.Save;
end;

// Optionaly set the page size and index
LContactsTable.PageSize = 20;
LContactsTable.PageIndex = 0;

// Optionaly add one or more filter conditions
LContactsTable.Filters.Add('Name', coLike, 'John'); 
LContactsTable.Filters.Add('Email', coEndsWith, 'gmail.com', loAnd); 

// Optionaly add one or more sorting statements
LContactsTable.Sorting.Add('Company', soAscending); 
LContactsTable.Sorting.Add('Name', soDescending); 

// execute the query
LContactsTable.Query();

// now you can use the result of that query by accessing the Entities property
for LContact in LContactsTable.Entities do
begin
    ContactsListBox.items.Add(LContact.GetValue('Name'));
end;

Blobs

// Check if the current user can use blob fields
if MyCloudData.CurrentUser.CanUseBlobFields; then
begin
    // Add the field to the table
    LContactsTable.Fields.AddOrUpdate('Picture', ftBlob);
end;

var
LPictureField : TmyCloudDataBlob;
begin
    // Fetch the Entities on the table
    LContactsTable.Query();

    // Get an entity by its ID
    LContact := LContactsTable.Entities.GetEntity(LEntityId);

    // Get the blob field 
    LPictureField := LContact.GetBlobField('Picture');

    // Save a new image
    LPictureField.FromFile('c:path	oyourimage.jpg');
end;

(Este link em português)

Intensive Delphi 2016 is happening right now. It's the biggest online Delphi event in Brazil, and it's free for everyone! Already started on Monday, 19th and going on until 24th, it's six days full of sessions about the most different topics: Mobile development, Rest/JSON servers, Firemonkey, VCL, Beacons, Arduino, best practices, and many many more.

To access the conference, use the follow link: Intensive Delphi 2016 Official Link



Each day starts as early as 8 am local brazilian time, and goes on until up to 10 pm at night. Outside the official schedule for session streaming, sessions replays are provided in those alternative schedules. The chat windows is available for you to interact with speakers at specific session times, specially at night (brazilian time).

There will be sessions available in both Portuguese (most of them) and English.

More than 25 speakers and counting will be present at conference, including Marco Cantu, Jim Mckeeth and, from TMS Software, Wagner Landgraf with a session about TMS Business product line. The TMS Business session schedule is Thursday, 22th, 8 pm brazilian time (UTC-02:00) and Wagner will chat with attendees. Here is the full list of speakers in alphabetical order:

Adriano Santos
Alan Glei
Alan Victor (Bruto do Delphi)
Alister Christie
Amarildo Lacerda
Boian Mitov
Carlos Agnes (Tatu)
Emanoel Deivison
Jackson Gomes
Jim Mckeeth
Jonatan Souza
Jorge Eduardo
Kelver Merlotti
Kleberson Toro
Laercio Guerco
Landerson Gomes
Marco Cantu
Marcos Moreira
Marcus Vinicius
Mauricio Abreu
Newton Oliveira
Regys Silveira
Ricardo Boaro
Rodrigo Mourao
Samuel "Muka" David
Thulio Bittencourt
Wagner Landgraf (TMS Software)

The ability to lazy-load an association is placed at number 8 in the list of My Top 10 Aurelius Features.


Suppose you have a TContact class like the following:

type
  TContact = class
  private
    FId: integer;
    FName: string;
    FCountry: TCountry;
  public
    property Id: integer read FId write FId;
    property Name: string read FName write FName;
    property Country: TCountry read FCountry write FCountry;
  end;

// Get all contacts
MyContacts := Manager.Find<TContact>.List;

// Get name of country of first contact:
FirstContactCountryName := MyContacts[0].Country.Name;

SELECT A.ID AS A_ID, A.NAME AS A_NAME, A.COUNTRY_ID AS A_COUNTRY_ID, B.ID AS B_ID, B.NAME AS B_NAME
FROM CONTACT A LEFT JOIN COUNTRY B ON (B.ID = A.COUNTRY_ID)

type
  TContact = class
  private
    FId: integer;
    FName: string;
    FCountry: Proxy<TCountry>;
    function GetCountry: TCountry;
    procedure SetCountry(const Value: TCountry);
  public
    property Id: integer read FId write FId;
    property Name: string read FName write FName;
    property Country: TCountry read GetCountry write SetCountry;
  end;

function TContact.GetCountry: TCountry;
begin
  Result := FCountry.Value;
end;

procedure TContact.SetCountry(const Value: TCountry);
begin
  FCountry.Value := Value;
end;

SELECT A.ID AS A_ID, A.NAME AS A_NAME, A.COUNTRY_ID AS A_COUNTRY_ID 
FROM CONTACT A

SELECT A.ID AS A_ID, A.NAME AS A_NAME
FROM COUNTRY A

// Get all contacts and countries at once,
// regardless of lazy-load mode in mapping
MyContacts := Manager.Find<TContact>
  .CreateAlias('Country', 'c', TFetchMode.Eager)
  .List;

// Get name of country of first contact:
FirstContactCountryName := MyContacts[0].Country.Name;

With the new 1.7 release of the TMS FNC UI Pack we've added a completely new PDF library built from the ground up, that is capable of generating PDF files on all supported frameworks (FMX, VCL, LCL). Via all supported frameworks, you can easily target minimum 5 different operating systems: Windows, macOS, iOS, Android, Linux (&Raspbian),.. To introduce this new PDF library I've written a small tutorial to start generating your own PDF files.

procedure TForm1.GeneratePDF(AFileName: string);
var
  p: TTMSFNCPDFLib;
begin
  p := TTMSFNCPDFLib.Create;
  try
    p.BeginDocument(AFileName);
    p.EndDocument;
  finally
    p.Free;
  end;
end;

procedure TForm1.GeneratePDF(AFileName: string);
var
  p: TTMSFNCPDFLib;
begin
  p := TTMSFNCPDFLib.Create;
  try
    p.BeginDocument(AFileName);
    p.NewPage;
    p.EndDocument;
  finally
    p.Free;
  end;
end;

procedure TForm1.GeneratePDF(AFileName: string);
var
  p: TTMSFNCPDFLib;
begin
  p := TTMSFNCPDFLib.Create;
  try
    p.BeginDocument(AFileName);
    p.NewPage;
    p.Graphics.Stroke.Color := gcRed;
    p.Graphics.Stroke.Width := 3;
    p.Graphics.Stroke.Kind := gskDashDotDot;
    p.Graphics.Fill.Kind := gfkGradient;
    p.Graphics.Fill.Color := gcBlue;
    p.Graphics.Fill.ColorTo := gcOrange;
    p.Graphics.DrawRectangle(RectF(10, 50, 100, 150));
    p.EndDocument(True);
  finally
    p.Free;
  end;
end;

procedure TForm1.GeneratePDF(AFileName: string);
var
    p: TTMSFNCPDFLib;
begin
    p := TTMSFNCPDFLib.Create;
  try
    p.BeginDocument(AFileName);
    p.NewPage;
    p.Graphics.Font.Name := 'Segoe UI';
    p.Graphics.Font.Size := 16;
    p.Graphics.Font.Color := gcRed;
    p.Graphics.Font.Style := [TFontStyle.fsBold];
    p.Graphics.DrawText('Hello World !', PointF(10, 50));
    p.EndDocument(True);
  finally
    p.Free;
  end;
end;

procedure TForm1.GeneratePDF(AFileName: string);
var
  p: TTMSFNCPDFLib;
  s: string;
  r: TRectF;
begin
  p := TTMSFNCPDFLib.Create;
  try
    s := 'Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum     has been the industry''s standard dummy'+
'text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. '+
'It has survived not only five centuries, but also the leap into electronic typeset'+
'ting, 
remaining essentially unchanged. It'+
' was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with des'+
'ktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.';
    p.BitmapContainer := TMSFNCBitmapContainer1;
    p.BeginDocument(AFileName);
    p.NewPage;
    p.Graphics.Font.Name := 'Arial';
    p.Graphics.Font.Size := 10;
    p.Graphics.Fill.Color := gcNull;
    r := RectF(10, 50, 300, 400);
    p.Graphics.DrawHTMLText(s, r);
    p.EndDocument(True);
  finally
    p.Free;
  end;
end;

When creating a database-based application, one of the tasks I always considered boring was to create the database structure, table, fields, foreign keys. Even using a tool to generate a SQL would require me to create a table, add columns, column types, foreign keys, etc.

That's why I consider the ability to automatically create and update the database schema to be the #7 feature of My Top 10 Aurelius Features. It's simply something I don't need to care about anymore.



Updating the database is as easy as doing this:

TDatabaseManager.Update(Connection);

procedure TForm1.ValidateMyDatabaseSchema;
var
  DBManager: TDatabaseManager;
  Action: TSchemaAction;
  Warning: TSchemaWarning;
  Error: TSchemaError;
begin
  DBManager := TDatabaseManager.Create(Connection);
  try
    DBManager.ValidateDatabase;

    { Show SQL statements }
    mmStatements.Clear;
    for Statement in DBManager.SQLStatements do
    begin
      mmStatements.Lines.Add(Statement);
      mmStatements.Lines.Add('');
    end;

    { Show validation results }
    mmValidation.Clear;

    mmValidation.Lines.Add('----- Actions -----');
    for Action in DBManager.Actions do
      mmValidation.Lines.Add(Format('%s -> %s', [Action.ClassName, Action.Text]));
    mmValidation.Lines.Add('');

    mmValidation.Lines.Add('----- Warnings -----');
    for Warning in DBManager.Warnings do
      mmValidation.Lines.Add(Format('%s: %s', [Warning.ClassName, Warning.Text]));
    mmValidation.Lines.Add('');

    mmValidation.Lines.Add('----- Errors -----');
    for Error in DBManager.Errors do
      mmValidation.Lines.Add(Format('%s: %s', [Error.ClassName, Error.Text]));
  finally
    DBManager.Free;
  end;
end;

To begin 2017, here is an update on TMS Cryptography Pack, that has now been available for six months. We received several bug reports and requests for new features that are listed in the Excel spreadsheet in the link.

The good news is that no bug related to one of the cryptographic engines was reported and that we only found a single pure cryptographic bug. This bug was identified in the SPECK 24 bit mode and escaped our detection because the test program returned " true " independently from the test result of this mode. Hopefully no user was impacted.

There is one critical bug left for users who don't want to use or ship VCRuntime140.dll required for Windows 64 bit applications. This requirement is due to the use of Visual Studio C++ to generate the object files for Windows 64 as Embarcadero doesn't provide the required object format to interoperate with Pascal Object code. A bug report has been sent to Embarcadero.

There are 4 feature requests that we will address in the upcoming releases of TMS CP. They are:
- ASN.1 (BER, DER, CER, OER encodings)
- XADES/CADES/PADES signatures
- Unicode support for file names
- Stream operations support

We are always open to new suggestions.

The video series "My Top 10 Aurelius Features" continues. The #6 feature is the support for Legacy Databases, and the following video shows it in action. English and Portuguese subtitles available!



In my opinion, TMS Aurelius will be very limited if it required a very strict database schema/structure. It would be great for creating prototypes and new applications from scratch, but a no-no for existing applications and databases - and we all know that in Delphi world, what we have most is existing and legacy applications!

That's why Aurelius provides an extensive list of mapping attributes that makes it compatible with virtually any existing database structure you might have. Attributes like

Id
Allows you to use databases with different primary key, like GUID, String, UUID, or even Composite Id's

Column and JoinColumn
Allows you to specify how one table relates to another (foreign keys) even if it doesn't reference a primary key in parent table (an unique index might be used).

Those are just small examples. And the best part is that you don't need to map it yourself. You can use the TMS Data Modeler tool to import an existing database structure and generate all the mapping for you!

Please watch the video for more details and to see TMS Data Modeler source code generation in action.

As usual, don't forget to subscribe to our YouTube channel and receive notifications about upcoming videos!

We have given up thinking that the TMS Component Pack will ever be complete. It is simple: It will never be complete! On a daily basis, we're in conversation with developers around the planet with interesting, useful and cool new ideas. Between waking up and going to sleep, we ponder all the time how to improve components, how to make developers write less code and do more, to design new controls for bringing functionalities that don't exist out of the box in Delphi & C++Builder. And yes, some nights while sleeping, we also dream about new cool stuff to do.
As we've now just released and reached a new milestone with TMS Component Pack v8.5, it's good to take a moment and bring to the attention all the new goodies that are packed in the new release, so, sit back, hold tight, here we go with the list:

New: TDBAdvSearchList
DB-aware version of the TAdvSearchList component
The TDBAdvSearchList is a DB-aware of TAdvSearchList. This means that the data in the list in the different columns can be automatically filled from a connected dataset via a datasource. Set TDBAdvSearchList.DataSource and DBAdvSearchList.Columns[x].DataField to specify binding of values in the columns of the list. When the DB field bound to a column is of the type TBlobFiled, the list control will try load the blob data as a picture.


New: TDBAdvSearchEdit
DB-aware version of the TAdvSearchEdit component
The TDBAdvSearchEdit is DB-aware version of the TAdvSearchEdit with respect to the value as well as with respect to the list of values. Set TDBAdvSearchEdit.DataSource and TDBAdvSearchEdit.DataField to define the DB-awareness of the value and use TDBAdvSearchEdit.ListSource in combination with TDBAdvSearchEdit.Columns[x].DataField to specify binding of values in the columns of the list.


New: TDBAdvResponsiveList
DB-aware version of the TAdvResponsiveList component
The TDBAdvResponsiveList is a DB-aware version of the TAdvResponsiveList. Header, content and footer of responsive list items can be loaded automatically from a dataset connected via a datasource. Set the datasource via TDBAdvResponsiveList.DataSource. The binding of values to items is done via item templates. The template placeholders are defined as (#FIELDNAME) and are dynamically rendered when the dataset is activated. Memo fields can be used as well as picture blob fields. For picture blob fields, specify the template value to render as picture as:

<IMG src="(#BLOBFIELDNAME)">




New: TAdvPDFLib
Standalone PDF library to generate PDF files easily on-the-fly.
Library that features PDF file generation with text, formatted text, rectangles, lines, polygons, images, ... header, footer access and custom drawing.



There is a new developers guide specifically covering the new PDF generation library.
This is also the library that is used under the hood to do out of the box PDF generation from our grids, richeditor, planner, memo!

New: TAdvPDFImageBook
Class that can on-the-fly generate PDF files from a list of images

TAdvResponsiveList
- New: HeaderTemplate capability added
Now also for the item header, a template can be specified. The template placeholders are just like for the content specified as (#VALUENAME). The template is rendered by using the TResponsiveListItem.Values['VALUENAME'] value and have specifiers like (#VALUENAME) replaced by these values.
- New: FooterTemplate capability added
Same as the header template but for the optional footer of the item
- New: Appearance.ItemContentMargin added
New property to specify the margin from left/right and top/bottom of the content with respect to the outline of the item.
- New: Filter capability
Items in the TAdvResponsiveList can now be easily filtered. The filter condition is set via TAdvResponsiveList.FilterCondition. Following properties are available:
FilterCondition.CaseSensitive: Boolean : when true, a case-sensitive match is performed

FilterCondition.FilterData: TResponsiveListItemFilterDataSet : defines on what data to filter : the header, the content or the footer.

TResponsiveListItemFilterData = (fdContent, fdHeader, fdFooter);
TResponsiveListItemFilterDataSet = set of TResponsiveListItemFilterData;

FilterCondition.FilterType: TResponsiveListItemFilterType : defines what match method to use:

TResponsiveListItemFilterType = (mText, mEntireWord, mStartWord, mEndWord);

mText: match of any part of the text
mEntireWord: match of text respecting word boundaries
mStartWord: match must be at start of a word
mEndWord: match must be at end of a word
FilterCondition.Text : string : holds the text to perform a match against
The filter operation is started by setting the filter condition and then call:

TAdvResponsiveList.UpdateFilter;

TAdvResponsiveList.ClearFilter;

var
  it: TNeedleItem;
  I: Integer;
begin
  for I := 0 to 10 do
  begin
    it := AdvGauge1.ExtraNeedles.Add;
    it.Position := i * 10;
    if odd(i) then
      it.Color := clLime
    else
      it.Color := clAqua;
  end;
end;

John Kouraklis has posted a 2-part article in his blog about using TMS Aurelius and MVVM. From the article: "Model-View-ViewModel (MVVM) design pattern allows developers to write software in a way that separates applications to layers that serve the business logic, the presentation logic and the elements of the user interface."

You can follow the links below to read the article:

http://www.kouraklis.com/2017/01/tms-aurelius-and-mvvm-design-an-example/
http://www.kouraklis.com/2017/01/tms-aurelius-and-mvvm-design-an-example-part-2/

He's also published the "MVVM in Delphi" book, you can purchase it from Amazon. More info about the book here.

Most examples and quick-start tutorials about ORM frameworks explain how to insert, update and retrieve single entities in the database. But not many of them go further and show how to perform a query in the database. Maybe because that's something that the developer will only need after many data is inserted, and it's something that is only heavily needed when the application development is at a more advanced stage. However, it's a very important feature, and that's why "LINQ Expressions and Paging" is my #5 feature of My Top 10 Aurelius Features.



The reason for that is because you can really query your entities in a object-oriented way. It's not some SQL-like string you build, or SQL WHERE statement that you simply inject. It's really about querying object properties, comparing their values in Pascal (not in database), and using Pascal syntax to build the queries. Take a look at this example:

  MyCustomers := Manager.Find<TCustomer>
    .Where(
      (
         (Linq['Birthday'] > EncodeDate(1981, 10, 10))
         and (Linq['Birthday'] < EncodeDate(1986, 2, 2))
      )
      or ((Linq['Sex'] = tsFemale) or Linq['Sex'].IsNull)
      or Linq['Name'].Contains('Walker')
      or Linq['Status']._In([TCustomerStatus.Active, TCustomerStatus.Prospect)
    )
    .OrderBy('Name')
  .List;

  MyCustomers := Manager.Find<TCustomer>
    .Take(10).Skip(50)
    .OrderBy('Name')
    .List;

With the 1.7.1.0 release of the TMS FNC UI Pack we have introduced a TMS FNC Core separation. This means the TMS FNC Core needs to be installed as a prerequisite in order to successfully install the TMS FNC UI Pack. Apart from this separation, the new core setup will not introduce breaking changes in your application, as the file names for both the TMS FNC Core and TMS FNC UI Pack have remained the same. The separation gives us the benefit of writing components that all rely on a single core, instead of duplicating units that offer exactly the same features in multiple component sets. All current and future TMS FNC products will build upon this common core.

Custom Component Development for FNC

[FMX.][VCL.][LCL]TMSFNCBitmapContainer.pas
[FMX.][VCL.][LCL]TMSFNCCustomComponent.pas
[FMX.][VCL.][LCL]TMSFNCCustomControl.pas
[FMX.][VCL.][LCL]TMSFNCCustomScrollControl.pas
[FMX.][VCL.][LCL]TMSFNCGraphics.pas
[FMX.][VCL.][LCL]TMSFNCGraphicsTypes.pas
[FMX.][VCL.][LCL]TMSFNCHTMLEngine.pas
[FMX.][VCL.][LCL]TMSFNCStyles.pas
[FMX.][VCL.][LCL]TMSFNCTypes.pas
[FMX.][VCL.][LCL]TMSFNCURLBitmapContainer.pas
[FMX.][VCL.][LCL]TMSFNCUtils.pas

We already provide help and documentation in several ways: PDF developer guides for most complex components, a page with component specific tips and FAQ, a monthly knowledge base alert, ... . our TMS Support Forum with almost 10.000 forum members also offers a big help to many users. And of course our first-class support directly from our developers here at the office.

But we listened to your feedback and it was clear that many of you also wanted in addition to this videos explaining the products and offering step by step demos. So, we made it an action point and commitment for 2017 to significantly increase our offerings in videos.

With our video's we would like to show you step by step what great features our components are offering without the need to install trial versions or spend a lot of time reading through all our documentation. No hassle, just 1 click on the video and you can see our components in action, be it in VCL applications, cross-platform FMX applications, Cloud, Intraweb, ...

To show our commitment, here are already the first 3 videos we created this year in January and more will be following shortly:

Video 1 about how you can effortlessly generate pdf files from a VCL DB grid.

Video 2 about how you can use the mycloudData service which is a cloud service for structured cloud storage for data.

Video 3 about responsive design in VCL applications with the TDBAdvResponsiveList.

I consider Aurelius Dataset (TAureliusDataset) a hidden gem of TMS Aurelius. Well, not exactly "hidden" because it's a significant part of it to deserve its own chapter in the Aurelius documentation, but in the sense that it's different from the normal ORM "core" which is update, insert, delete, select, query, etc.. And for that it's #4 of My Top 10 Aurelius Features.



The first misunderstanding about the TAureliusDataset is confusing its usage with the regular way we use Delphi datasets. I've been in discussions in forums with people that were blaming the usage of dataset, because it's not "good practice", because logic should be in the controller/model, etc., etc..

The point is Aurelius Dataset is for data binding. It's not about retrieving data. You will retrieve data the same way with or without the dataset. Your logic, controller and model will still be isolated. But when it comes to show or edit data of an entity in a visual form, you don't have to manually do things like this:

edCustomerName.Text := Customer.Name;
edCustomerCity.Text := Customer.City;

Grid.Clear;
for Customer in Customers do
begin
  CurrentRow := Grid.AddRow;
  Grid.Columns[0, CurrentRow] := Customer.Name;
  Grid.Columns[1, CurrentRow] := Customer.City;
end;

AureliusDataset1.SetSourceList(MyCustomerList);

AureliusDataset1.SetSourceObject(MyCustomer);