In the past couple of years, I not only realized how crucially important it is to nuture new generations of Delphi enthousiasts but I also learned myself how much I personally enjoy sharing my passion for Delphi with students.

The magic moment is that when students experience themselves that awesome projects can be done with Delphi and that the software development process can be fun and intuitive. The blink in the eyes of a student seeing the virtually unlimited possibilities of software development is so incredibly gratifying. Then I'm confident that the passion that drove myself the past 30 or so years will continue to live on.

So, this year we had again the pleasure to work with an intern. Albeit this year it was complicated due to Covid-19 and being forced to close the office and do all work from home. But this didn't stop our intern Luc Levez from doing a great job. Within the period of the internship, Luc Levez familiarized with Delphi and in particular with TMS WEB Core in Delphi with no prior knowledge of Delphi or Object Pascal. But that was not all. Luc also familiarized with ESP32 devices he had never used before. And it doesn't end there. Add to that the for Luc unknown territory of Bluetooth communications. Wireless communication always remains a kind of magic.

Luc worked together with us to produce an as seamless, easy and intuitive to use component for doing communications with a Bluetooth device from a TMS WEB Core web client application. This will be available in the upcoming TMS WEB Core v1.4 Ravenna. Yes, you run the application in a browser, connect to a device in the reach of the machine where the web application is running on and you can start exchanging data with the Bluetooth device. In the project of Luc, we have setup this Bluetooth communication with an ESP32 device. This permits the freedom to control via this ESP32 whatever we want.

Next week Luc will publish a full article with technical details but for the weekend, you can already enjoy this video Luc created.



Many thanks Luc for such a great time collaborating even in far from ideal circumstances in these challenging times.

As you can see, internships are exciting at tmssoftware.com, even in covid19 times. If you are a student and want to experience this adventure here during your internship, get in touch with our team!

We are thrilled to announce the release of TMS WEB Core v1.4! The new version not only introduces a record number of improvements, amazing new features but also supports the latest and greatest Delphi 10.4 Sydney. The new version v1.4 is available free for all active registered TMS WEB Core or TMS ALL-ACCESS users

TMS WEB Core v1.4 represents multiple months of hard work from our team, some parts have been over 6 months in development.
Here is a summary of what you can discover in the TMS WEB Core v1.4:

• New TWebBluetooth Non-visual component offering seamless access to Bluetooth devices from web applications
• New TWebImageSlider UI control to make presenting catalogs with pictures fast and easy
• New TWebContinuousScroll UI control to bring fast loading and load-as-you-scroll lists
• New TWebElementActionList to facilitate binding Pascal code to HTML template elements
• New TWebRadServerClientDataset offering a codeless interface to data from Embarcadero RAD server
• New TWebDreamFactoryClientDataSet making consuming data via DreamFactory REST APIs a breeze
• New TWebFaunaDBClientDataSet letting you bind cloud data in web client applications code-less
• New Electron 8 support allowing you to take advantage of the newest stable Electron framework for building cross platform desktop applications
• New TWebSignatureCapture allowing to capture touch based signature writing as image in web applications
• New TWebPayPal migrated to the newest PayPal JavaScript SDK
• New demos for TWebListControl, TWebElementActionList, HTML templates, TWebBluetooth, PDF streaming, TWebSignatureCapture, various DB backends
• New latest stable release pas2js 1.4.24 compiler & RTL support added
• New TBitmap load from URL, file, cache with anonymous method added
• New TWebHttpRequest anonymous methods for handling asynchronous requests in a different way

Book: TMS WEB Core: Web Application Development with Delphi



TMS WEB Core v1.4 for Delphi/Lazarus is available standalone now and is also part of TMS ALL-ACCESS. Do you have already one or more TMS product licenses and are interested to get on board for TMS ALL-ACCESS, our no-nonsense formula for access to our full current and future toolset, priority support and access to betas, contact our sales: sales@tmssoftware.com for a best possible upgrade offer.

TMS WEB Core v1.4 is released and one of the many exciting new components added is the TWebBluetooth component to make it seamless to access Bluetooth devices from your web applications. At this moment, all modern web browsers except Safari, offer the web Bluetooth API for this. We can only hope that Apple will soon follow this trend.

With more than 4 billion Bluetooth devices produced in 2019, including all current smartphones, tablets, laptops, TV’s, and speakers on the market, Bluetooth has truly started a revolution. By 2023, up to 90% of all Bluetooth devices will have Bluetooth Low Energy (BLE) capability. With that in mind TMS Software is providing you with the tools to embrace this exciting technology and run with it.

The TWebBluetooth component and supporting classes allows for quick and easy development of all your Bluetooth Low Energy applications, bringing device functionality straight to the browser. To get up and running, just add the WEBLib.Bluetooth library to your TMS Webcore project under uses and you will gain access to the following features:

TBluetooth component: Used to create an instance of a Bluetooth Device. It contains methods for filtering which devices you wish to connect to.

Device class: It contains methods for establishing and maintaining a connection to, or disconnecting from the GATT server. It also contains methods allowing access to and discovery of services on a device.

Service class: It can be seen as a container for characteristics. The service class contains methods allowing access to and discovery of its characteristics.

Characteristic class: This is the main component of any BLE device. Reading and writing to these characteristics gives you control over a device. Our Characteristic class contains options for reading, writing and notifying data of all different data types/data streams to and from a Characteristic. Characteristics also contain methods for accessing and discovering its descriptors.

Descriptor class: Descriptors contain information about their characteristics. The Descriptor class has methods for reading and writing to descriptors.

To demonstrate how easy our tools are to use, I have configured an ESP-32 with a BME-280 temperature, humidity and pressure sensor. The ESP-32 is a microcontroller with onboard Bluetooth functionality. Using the BLE Server library with the Arduino IDE, I created a service with 4 characteristics. The first characteristic will be used to store and retrieve an integer value. The second is configured to control the onboard LED, allowing us to turn it on and off. The final two characteristics are set to retrieve temperature and humidity readings.

Getting started

 Public
  { Public declarations }
  bt: TBluetooth;
  MyDevice: TBluetoothDevice;
  MyService: TBluetoothService;
  IntCharacteristic: TBluetoothCharacteristic;
  LedCharacteristic: TBluetoothCharacteristic;
  TemperatureCharacteristic: TBluetoothCharacteristic;
  HumidityCharacteristic: TBluetoothCharacteristic;

const
  MyServiceUuid = '4c652180-1201-4fdf-b853-36bac4cced0a';
  IntUuid = 'fa67024c-78d6-11ea-bc55-0242ac130003';
  LedUuid = 'fa66fffe-78d6-11ea-bc55-0242ac130003';
  TemperatureUuid = '14f3ff86-95b8-11ea-bb37-0242ac130002';
  HumidityUuid = '14f4038c-95b8-11ea-bb37-0242ac130002';
  UserDescUuid = '0x2901';
  DeviceName = 'Custom_ESP32';

Setting up BLE

procedure TForm7.WebButton1Click(Sender: TObject);
begin
  bt := TBluetooth.Create;
  bt.FilterService.Add(MyServiceUuid);
  bt.DeviceName := 'Custom_ESP32';
  bt.GetDevice(
    procedure
    begin
      bt.Device.Connect(
      procedure
      begin
        bt.Device.GetService(myServiceUuid,
        procedure(AService: TBluetoothService)
        begin
          AService.GetCharacteristic(IntUuid,
          procedure(AChar: TBluetoothCharacteristic)
          begin
            IntCharacteristic := AChar;
          end);

          AService.GetCharacteristic(LedUuid,
          procedure(AChar: TBluetoothCharacteristic)
          begin
            LedCharacteristic := AChar;
            LedCharacteristic.Read(
            procedure(AValue: integer)
            begin
              ReadLedCharacteristic(Self, AValue);
            end);
          end);

          AService.GetCharacteristic(TemperatureUuid,
          procedure(AChar: TBluetoothCharacteristic)
          begin
            TempCharacteristic := AChar;
            TempCharacteristic.OnNotifyDouble:= NotifyTempCharacteristic;
          end);

          AService.GetCharacteristic(HumidityUuid,
          procedure(AChar: TBluetoothCharacteristic)
          begin
            HumCharacteristic := AChar;
            HumCharacteristic.OnNotifyDouble:= NotifyHumCharacteristic;
          end);

          EnableButtons;
        end);
      end);
    end);
end;

Pairing the Device

Reading data

procedure TForm7.WebButton4Click(Sender: TObject);
begin
  intCharacteristic.Read(
  procedure(AValue: integer)
  begin
    WebLabelReadValue.Caption:= IntToStr(AValue);
  end);
end;

Writing data

procedure TForm7.WebButton5Click(Sender: TObject);
begin
  IntCharacteristic.WriteInt(StrtoInt(WebEdit1.Text));
  ShowMessage('Wrote value of ' + WebEdit1.Text + ' to device');
end;

Expanding this concept to real world devices

• LedCharacteristic.WriteInt(1); to turn on the LED.
• LedCharacteristic.WriteInt(0); to turn off the LED.

Realtime sensor readings

AService.GetCharacteristic(TemperatureUuid,
procedure(AChar: TBluetoothCharacteristic)
begin
  TemperatureChar:= AChar;
  TempCharacteristic.OnNotifyDouble:= NotifyTempCharacteristic;
end);

Summary

• Code once, run everywhere for wireless interaction with real world devices in the browser.
• Effortless implementation, allowing you to turn on/off devices, change their settings or enable communication between different devices using the Read, Write and Notify methods.
• Quick and easy development of Web Bluetooth projects, all within the Object Pascal language.

TMS WEB Core v1.4 Ravenna has new features and improvements on all levels. There are many RTL improvements like different new type helpers, the TStringBuilder and lots more, there is Bluetooth device connectivity, there are several new options for using data back-end APIs like Embarcadero RAD server, FaunaDB, DreamFactory, there is enhanced HTML template binding with the TWebElementActionList, there are many IDE integration improvements like hierarchical folder import to facilitate HTML template usage and of course, there are also improvements on UI controls and also new UI controls!

Today, our colleague chief evangelist Dr. Holger Flick prepared videos showing you the new TWebImageSlider and the new TWebContinuousScroll.

TWebContinuousScroll

Whenever there is a scenario where a list of information to be displayed to a user is very large, a convenient pattern is to show in the UI the initial first number of items filling the screen and only fetch more items as the user scrolls through the list. The advantage here clearly is that the page comes up very fast, will never load more items than the user wants to see and fetches extra items only as the user scrolls through the list. We have encapsulated all this functionality into a single new easy to use component TWebContinuousScroll. How it can be used is explained in this video or you can explore it directly in a demo application. Be sure to also try out this demo on a smartphone as the control is obviously also designed for use in responsive web applications.



TWebImageSlider

Very often, one wants to present a selection of pictures of a product, a person, a house, a car to users in a web application. This is then typically done with a list of picture thumbnails one can click to view the large image or means to scroll trough the list of pictures. For this often used pattern, we created a new UI control TWebImageSlider that makes offering this UI as easy as filling a TStringList with URLs of images to be displayed. Dr. Holger Flick explains all in more detail with his newest video or try out the new component with our live demo.



Don't stay behind, discover TMS WEB Core v1.4 now!

Active registered users of TMS WEB Core get the new version v1.4 free. Login on our website and download the newest release. Not yet a TMS WEB Core user? Signup for a fully functional trial version of TMS WEB Core now also supporting the newest Delphi 10.4 Sydney.

Excited about all the hot technology we offer for Delphi & C++Builder developers, get your VIP seat with TMS ALL-ACCESS, our no-nonsense subscription to our entire product offerings, priority support and access to betas (such as the upcoming TMS WEB Core for Visual Studio Code!

Look and Feel

FNC Styles

• Built-in styles
• Custom styles

JSON based

{
   "$type":"TTMSFNCCalendar",
   "Color":"#484848",
   "DateAppearance":{
      "$type":"TTMSFNCCalendarDateAppearance",
      "BadgeFill":{
         "$type":"TTMSFNCGraphicsFill",
         "Color":"#FF0000",
         "ColorMirror":"gcNull",
         "ColorMirrorTo":"gcNull",
         "ColorTo":"#808080",
         "Kind":1,
         "OnChanged":null,
         "Opacity":1,
         "Orientation":1,
         "Texture":"",
         "TextureMode":2
      },
      "BadgeFont":{
         "$type":"TTMSFNCGraphicsFont",
         "Color":"#FFFFFF",
         "Family":"Segoe UI",
         "Name":"Segoe UI",
         "OnChanged":null,
         "Size":10,
         "IsFMX":true,
         "Style":0
      },
      "BadgeStroke":{
         "$type":"TTMSFNCGraphicsStroke",
         "Color":"#FF0000",
         "Kind":1,
         "OnChanged":null,
         "Opacity":1,
         "Width":1
      },
      "DateAfterFill":{
         "$type":"TTMSFNCGraphicsFill",
         "Color":"#484848",
...

Create your own style!

We are excited to announce that tmssoftware.com & FaunaDB entered a partnership and as a first result, TMS WEB Core v1.4 features out-of-box support for FaunaDB.

TMS WEB Core focuses on high productivity RAD component-based web client application development for Object Pascal developers and FaunaDB focuses on effortless serverless data access. Together, this offers a powerful combination for creating fast, secure web applications backed by the data correctness, capacity, redundancy, latency, and availability of FaunaDB.



Now, creating a web application dealing with user data is nothing more than creating an account at FaunaDB, creating a new database with data collections you want, define your queries and get an API key.

In the TMS WEB Core web client application, drop a TWebFaunaDBClientDataSet on the form, specify the CollectionName (table name), ClientKey (API-key) & persisted DB fields. Activate this dataset and all DB-aware UI controls connected via a TWebDataSource to this TWebFaunaDBClientDataSet will work directly on the FaunaDB data.



TMS WEB Core in Embarcadero RAD Studio, using the TWebFaunaDBClientDataSet dataset for a seamless connection to data on FaunaDB

The TWebFaunaDBClientDataSet has been designed to also work seamlessly in multi-user/multi-account scenarios. Therefore, at TWebFaunaDBClientDataSet level, a UserCollectionName can be set and a user login and signup function is integrated at dataset level.

It is clear that the combination of web front-end development with TMS WEB Core with data in the backend managed by the serverless FaunaDB service offers an unparalleled combination to develop and deliver secure, reliable, high performant web-based applications fast.

Our chief evangelist Dr. Holger Flick explains all in detail in a special video about this:



You can now explore this first result of our partnership by downloading TMS WEB Core v1.4 from https://www.tmssoftware.com/site/tmswebcore.asp and create a FaunaDB account at https://www.faunadb.com.

  

As software developers having worked from home during the covid-19 lockdown, chances are you will have communicated with colleagues or customers over the web and shared audio, video, desktop... all from the browser. And to do this, no software installation was needed and it works on any Windows PC, macOS Apple device or Linux computer with a modern browser. The wonderful technology behind this is WebRTC (Web Real-Time Communication) and is an open-source protocol specification/protocol controlled by the World Wide Web Consortium (W3C).

WebRTC is usable on one side via the WebRTC API meanwhile available in any current popular browser and on the other side WebRTC servers.

During the covid-19 lockdown, Michael Van Canneyt, one of the two masterminds behind the pas2js compiler and RTL, was tasked to write a web application for real-time video communication. For his project, the web application could make use of existing free to use WebRTC servers Jitsi or OpenTok.

As Jitsi and Tokbox offer both JavaScript libraries for WebRTC communication with their servers from a web application, Michael wrote the necessary Object Pascal classes for consuming these WebRTC libraries from a TMS WEB Core web client application. Michael Van Canneyt was so impressed with these libraries, that he re-created and extended these classes for inclusion in pas2js so the open-source community could enjoy them and also wrote two demos for the TMS WEB Core framework using these classes and showcasing the integration of real-time video communication from a TMS WEB Core application.


Demo running with 3 attendees in a room and cameras of two attendees pointing to each other's screen

You can explore the Jitsi demo here:

https://download.tmssoftware.com/tmsweb/demos/jitsi/

You can explore the Opentok demo here:

https://download.tmssoftware.com/tmsweb/demos/opentok/

Note that for Opentok you need to register for an OpenTok API key, Session ID and Token from Tokbox. After getting this information from a test account, you can use OpenTok free.

The full source code of both demos can be downloaded here. You need the latest version of TMS WEB Core v1.4 Ravenna for this. You will notice that these demos are HTML template based. That means that the layout of the page is done with HTML/CSS (Bootstrap) and bound to TMS WEB Core web controls via which all UI logic is provided. The nice thing is that you can not only explore these projects via your Delphi IDE, but if you are a TMS ALL-ACCESS user, you can now also open and run these demos from our beta version of TMS WEB Core for Visual Studio Code on Windows, macOS or Linux.

It clear that web technology and TMS WEB Core exposing this in an easy RAD component based way to Object Pascal developers is fascinating. Let us hear your thoughts and comments or other challenges for web based applications you would want to see covered here!

Intro

• Default
• Dark
• Light
• Office 2019 White
• Office 2019 Black
• Office 2019 Gray

Getting Started

Designtime

Runtime

implementation

{$R 'TMSFNCStylesResources.res'}

TMSFNCStylesManager1.LoadStyleFromResource(‘TTMSFNCStyle_FNC_Dark’);

TMSFNCStylesManager.StyleResource := ‘FNC_Dark’;

JSON Formatting

{
"$type":"TTMSFNCCalendar",
"Color":"#484848",
"DateAppearance":{
"$type":"TTMSFNCCalendarDateAppearance",
"BadgeFill":{
"$type":"TTMSFNCGraphicsFill",
"Color":"#FF0000",
"ColorMirror":"gcNull",
"ColorMirrorTo":"gcNull",
"ColorTo":"#808080",
"Kind":1,
"OnChanged":null,
"Opacity":1,
"Orientation":1,
"Texture":"",
"TextureMode":2
},
"BadgeFont":{
"$type":"TTMSFNCGraphicsFont",
"Color":"#FFFFFF",
"Family":"Segoe UI",
"Name":"Segoe UI",
"OnChanged":null,
"Size":10,
"IsFMX":true,
"Style":0
},
"BadgeStroke":{
"$type":"TTMSFNCGraphicsStroke",
"Color":"#FF0000",
"Kind":1,
"OnChanged":null,
"Opacity":1,
"Width":1
},
"DateAfterFill":{
"$type":"TTMSFNCGraphicsFill",
"Color":"#484848",
...

WEB Support

procedure TForm1.WebButton1Click(Sender: TObject);
begin
WebFilePicker1.Files[0].GetFileAsText;
end;
procedure TForm1.WebButton2Click(Sender: TObject);
begin
TMSFNCStylesManager1.LoadStyleFromURL('http://localhost:8888/Project1/TTMSFNCStyle_FNC_Dar
k.style');
end;
procedure TForm1.WebFilePicker1GetFileAsText(Sender: TObject;
AFileIndex: Integer; AText: string);
begin
TMSFNCStylesManager1.LoadStyleFromText(AText);
end;

Create your own style!

Sometimes it might be interesting to capture the content of the browser window, or parts of the browser window, as an image and send it back to a server or service. This can be a handy utility especially for customer support when wanting to see what is on the user browser when something is happening. This is at first sight not trivial to do though. The browser window is rendered from the DOM and consists typically of a collection of HTML elements. So, how could we convert this DOM of HTML elements to an image?

Fortunately the world-wide web development offerings are so incredibly rich that also for this particular need a nice JavaScript library exists. The handy JavaScript library for this case is html2canvas, an open source library for this particular task.

The documentation of html2canvas isn't extensive but specifies the essence of what we need:

html2canvas(document.querySelector("#capture")).then(canvas => {
    document.body.appendChild(canvas)
});

 
  TScreenCaptureToCanvasProc = reference to procedure(ACanvas: TJSElement);
  TScreenCaptureToDataURLProc = reference to procedure(ADataURL: string);

  TWebScreenCapture = class(TComponent)
  public
    procedure CaptureElementToCanvasElement(AElement: TJSElement; Proc: TScreenCaptureToCanvasProc);
    procedure CaptureScreenToCanvasElement(Proc: TScreenCaptureToCanvasProc);

    procedure CaptureElementToDataURL(AElement: TJSElement; Proc: TScreenCaptureToDataURLProc );
    procedure CaptureScreenToDataURL(Proc: TScreenCaptureToDataURLProc);

    procedure CaptureElementToImageFile(AElement: TJSElement;AFileName: string; AType:TImageType);
    procedure CaptureScreenToImageFile(AFileName: string; AType:TImageType);
  end;

 
var
  sc: TWebScreenCapture;
begin
  sc := TWebScreenCapture.Create(Self);

  sc.CaptureScreenToCanvasElement(
    procedure(ACanvas: TJSELement)
    begin
      document.body.appendChild(ACanvas);
    end
  );
end;

 
var
  sc: TWebScreenCapture;
begin
  sc := TWebScreenCapture.Create(Self);

  sc.CaptureScreenToDataURL(
    procedure(ADataURL: string)
    begin
      WebMemo1.Lines.Add(ADataURL);
    end
  );

 
var
  sc: TWebScreenCapture;
begin
  sc := TWebScreenCapture.Create(Self);
  sc.CaptureScreenToImageFile('webcorescreen', TImageType.itPNG);
end;

  [ComponentPlatforms(TMSWebPlatform)]
  [JSLibReference('https://html2canvas.hertzen.com/dist/html2canvas.min.js')]
  TWebScreenCapture = class(TScreenCapture);

The My Products page is one of the most important parts of the TMS Software website for our customers. This is the place to download the latest version of all purchased products and review the license details. Over the past weeks this page has been improved a lot with a more compact view, quick and easy access to the downloads and several filtering options.

We are excited to make the V2 BETA available to all customers!

What's new and improved?

1 Live search

2 Toggle details

3 Active licenses

4 Live filter by category

5 Compact display with color coding

6 Quick and easy access to the downloads

Start using it now!

We're thrilled to launch from today the TMS WEB Core partner program. The TMS WEB Core partner program is created to let everyone participate, benefit from additional TMS WEB Core components and to offer exposure to individual developers and companies to make other TMS WEB Core developers aware of the extra tools and components created for TMS WEB Core.

Explore

• 40+ Smart HTML elements wrapper components
• Screen capture component
• Froala Editor wrapper component
• Vaadin mobile friendly UI control wrapper components
• Components for real-time video communication with Jitsi and OpenTok WebRTC services

Why a partner program?

Getting started

Benefits

Start developing today

A while ago we created an import tool to minimize the workload of importing web components into TMS WEB Core. We wanted to extend the capabilities of this import tool and adjust it as much as possible so it can handle a wider range of web component sets. If you take a look around the countless available libraries, you'll notice that many of the web components share the same functionality, so we wanted to pick something that stands out.

Our next target was the Vaadin UI Components. It is developed by Vaadin and the component pack is available through HTML and Java. It has free and open-source elements and apart from the different look and feel it also introduces some new components, such as Login and its overlay variant.



Another advantage is that many of the elements behave differently on smaller screens, making them a great candidate for mobile development. Below you can see the difference between the Date Picker and Tabs components on a bigger desktop and smaller mobile browser.



The online documentation is available for each component here under the "Free & open source components" section.

You can go ahead explore a selection of these components in our demo, and make sure to check it out on mobile devices too! We made this wrapper pack available for free as part of our new TMS WEB Core partner program, and you can download it from here.

To install, open, compile & install the package from the "Component Library Source" folder. This will install the design-time components.
For use at runtime, make sure that the "Core Source" folder is in your TMS WEB Core specific library path that you can set via IDE Tools, Options, TMS Web, Library path.

On June 23, 2020 TMS software and Barnsten organized a webinar: "Building web applications with TMS WEB Core : standard UI, HTML templates, FNC"

In this webinar, Bruno Fierens gave an overview of the different ways one can use to build user interfaces for web applications with TMS WEB Core.

1. VCL-like user interfaces with use of a few controls to achieve responsive design.
2. Introduction of the use of HTML templates with binding to TMS WEB Core client UI control logic from Delphi with the Object Pascal language.
3. The use of the FNC framework UI controls as another way to build web client applications from Delphi.

Discover more:

Support is an essential part of software development. Not only to get you up to speed if you are struggling with getting to know a new product but also if there is a problem with a product in an existing application. It is important to get good quality support when you need it.

Here at tmssoftware.com, we pride ourselves in providing the best possible support for our customers. We are constantly working on improving our support channels and one of those channels is getting a major overhaul today.

Introducing the TMS Support Center

Features

Structure

Access

Search

Uploads

Mobile friendly

Conclusion

What is FNC?

FNC logo (re-)design

My benefits as an TMS ALL-ACCESS user:

• No nonsense license to our entire product portfolio
• Receive all new components, products free added to your toolbox automatically
• Access to product betas
• Huge savings compared to purchasing separate products
• Includes free updates and support during your registration period
• Support for the latest editions of Delphi and C++Builder is available
• Enjoy the priority support services of our team
• A renewal after 1 year is offered at 70% discount from new license price 1695 EUR

Tools and components included in TMS ALL-ACCESS for:

• 1^st class VCL Windows applications.
• 1^st class cross-platform FMX applications (Windows, macOS, iOS, Android).
• 1^st class backend REST server applications (Windows, macOS, Linux).
• 1^st class REPORTING to XLS, XLSX, PDF, HTML.
• 1^st class modern web apps, progressive web apps, Electron cross-platform apps (Windows, macOS, iOS, Android, Linux, Web).

• TMS WEB Core: Web Application Development with Delphi
• TMS Software Hands-on with Delphi: Cross-platform Multi-tiered Database Applications: Web and Desktop Clients, REST/JSON Server, and Reporting

As announced a few months ago, we want to make our contribution to the Delphi community and most importantly to the aspiring future Delphi developer and hereby encouraging next generations of enthusiast Delphi developers.
In February we announced TMS VCL UI Pack as our first product in the TMS Academic Program.
With the Delphi Community Edition students already have an extremely powerful tool in their hands and we want to enrich this with offering our most popular products also free to students with the TMS Academic Program.

Today, we launch our second academic license in the TMS Academic Program and this is the TMS FNC UI Pack.
FNC is our power bundle that offers you a set of powerful & feature-rich UI controls that you can use in Delphi's VCL framework, TMS WEB Core framework and cross-platform FMX framework. It includes a wide range of UI controls to create Win32, Win64, macOS, iOS, Android and web applications with a single codebase and a single learning curve.
This academic license can be used with the brand new Delphi 10.4, just like the TMS VCL UI Pack Academic! Note though that the professional version of TMS FNC UI pack is still needed if you want to use it with the Lazarus IDE.

Supported frameworks:

1. Register for a free TMS FNC UI Pack Academic license with a school or university email address
   
   
2. Receive your credentials to login on our website via your student email address
   
   
3. Login and download your free TMS FNC UI Pack Academic installer
   
   
4. Install the product for the Delphi Community Edition
   
   
5. Enjoy being part of the TMS family with full access to our website, TMS support center, product updates for 1 year and develop great Delphi VCL applications

Did you Know… FNC logo redesign

1. Communicating with devices from a web applications with Bluetooth
   This session explains and shows what modern browsers offer for supporting Bluetooth communication from web applications. It demonstrates how the browser Bluetooth support can be encapsulated in a Pascal class with which connecting to and transferring data to and from Bluetooth devices becomes easy. A sample web application is created with Delphi that can access a Bluetooth sensor device and read its sensor data.
   
   
2. Leveraging mapping services in Delphi VCL, FMX and web applications
   Several mapping services offer not only geographical visualization but also routing, directions, location information and more. Among these services are Google Maps, Openstreet Maps, Bing, Here, MapBox, TomTom, ... Each of these services have specific advantages and disadvantages in terms of features and cost of using the service. With a proper architecture, it is not only possible to switch the mapping service with one line of code but also to combine services from different service providers in a single Delphi VCL,FMX or web application. This way, a calculated direction from Google Maps could be displayed on a map rendered by Openstreet Maps or the different direction calculation results from different providers could be easily compared against each other on a single map. This is demonstrated in the session for multiple platforms, multiple frameworks with a single code-base.

We prepared something special for your summer weekend or #staycation, a 90 minutes hands-on video about the new TMS FNC Mapping product!

Our chief evangelist Dr. Holger Flick guides you step by step using Delphi 10.4 Sydney with FireDAC to deal with a 3.5 million records database to show information in various ways on the TMS FNC Mapping components, the new mapping component from TMS software that you can use in VCL, FMX, LCL and WEB applications and where you can switch with one property among 7 mapping service providers.
At the same time, this hands-on video is also teaser for an upcoming new book in the hands-on series (See our previous blog for info about the first hands-on book)

In this hands-on video, you will learn:

• Introduction to database and fields
• Adding indexes for performance
• Introduction to FireDAC connections with FireDAC explorer
• Specific SQLite related topics are discussed
• Using queries with macros and parameters
• Adding properties for query values
• Providing a combo box with direct binding to the database
• Creating coordinates and bounds
• Visualization using markers and clusters
• Adding rectangles
• Focusing on specific areas of the map

• US : TMS Software Hands-on with Delphi: Cross-platform Multi-tiered Database Applications: Web and Desktop Clients, REST/JSON Server, and Reporting
• Germany : https://www.amazon.de/dp/B088BJLLWG
• UK : https://www.amazon.co.uk/dp/B088BJLLWG

Our team has continued to work around the clock to move TMS WEB Core to the next level. And after version v1.4 Ravenna, the next level will be v1.5 Rimini (RIM-in-ee).



For those who have followed TMS WEB Core from the beginning at v1.0 Brescia know by now that each new version is named after a city along the famous Mille Miglia race, more precisely, the race of 1955. For those interested in the history, you can read about it here. But I assume that most of you are just interested in what TMS WEB Core v1.5 will bring.

Well, our team has worked on all fronts. That is:

• Delphi IDE integration
• UI controls
• PWA support
• Electron support

1. Live preview

• 1. Make a change to a control's property,
• 2. add a new control on the form or change something in the layout and
• 3. press Ctrl-S.

2. HTML template import

3. Automatic operating system theme adoption

4. Access to the share sheet of mobile devices

5. Unobtrusive notifications using Bootstrap toast messages

6. Direct local database access for Electron desktop applications

7. Sentry service-based application JavaScript error and Object Pascal exception logging

8. TWebComboBox with csDropDown style

9. New grid.SaveToCSV() method

10. Tons of smaller component improvements