hcUpdateFramework is Released

A long time ago, in a place not so far away, I wrote a framework which allowed a corporation to update an application it had deployed to 100+ remote locations with slow internet connections. Back then there were a few alternatives to rolling your own, but nothing seemed to have the feature set and development commitment from a Delphi component vendor. As a result, it was decided that I should implement one. The entire AutoUpdate Framework was initially written in Delphi XE2. Although BITS was going to be used to transfer the files since it offers the ability to throttle bandwidth, in the end, for simplicity sake, web services were employed instead. Rather than a simple call to download an MSI, the framework provides a large degree of flexibility: Do you simply want to generate and apply a binary patch? Do you need to be able to apply a series of updates to bring the installation up to the current version? Do you want to compress/zip the files to be delivered? What about deploying additional files and removing obsolete ones? Do you want to display a list of changes so the user can choose whether they update? Do you want to notify the user that updates are available while they are using the application? Do you want to make the update mandatory so bug fixes that are causing data issues are squashed ASAP? Do you want to schedule the application of an update silently in the background at a given time in the middle of the night? All these scenarios are supported and with a custom deployment application, you can see what version each user is running, any errors in the update process and when they last launched the application. It would be easy to extend the Server to accept bug reports and create an integration to your bug tracking system and/or CRM.  Usage Telemetry could also be added, and if user’s don’t pay, an update can render your software inoperable. Recently I resurrected the code to provide updates to a client during COVID, so I added Firebird support and changed the data model to track registrations (new application users). It would be very easy to extend the system with your own custom licensing code and track where your new users are located and how many “conversions” from trialware or lite to full versions you’re getting. That’s the power of open source;  no waiting for a vendor to implement the features you want for your use cases. In subsequent posts, I will describe the moving parts of the system.
Read More

web & mobile developer magazine article on TMS WEB Core

It’s been over a year now since the first release of TMS WEB Core.
Meanwhile many developers have started first experimenting and then building new web technology based applications with the standalone version of TMS WEB Core and additional tools like TMS XData that are all included in TMS ALL-ACCESS. Some developers combined this with our FNC cross-platform components and have created extraordinary projects!

We were especially pleased to see this month that the well-known and respected German magazine on web development: “web & mobile developer” features an article on TMS WEB Core.
This is especially encouraging as it spreads the word about TMS WEB Core and more importantly the Delphi IDE to a wide community of software developers. Let’s hope it gets noticed and might convince developers to explore RAD component based web development in the Delphi world!

Here is a short summery of the article:

TMS WEB Core v1.6.1.0 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.

Read More

Read More

Quick and Dirty FireMonkey Donut Gauge

Someone was asking where they could find gauge style chart components for FireMonkey like the ones you might see on a dashboard. They even helpfully posted some pictures.At least one of these looks like it would be easy to reproduce without any third party components. The requirements are straight forward. Create a donut gauge chart similar to the one pictured here. It will operate like a
Read More

Async keyword in TMS WEB Core (Leon Kassebaum)

Async? What’s that?

Maybe you have already heard about the two concepts of synchronous and asynchronous processing of
code statements. I give you an example. Let’s have a look at a “normal” Delphi application and the
following lines of code:

procedure MyProc();
var
  lResponse : string;
begin
  lResponse := ExecuteServerRequest;
  lResponse := 'Response: ' + lResponse;
  Writeln(lResponse);
end;

I think you know this type of application (maybe a VCL or FMX app) and of course line 6 is executed
after receiving the servers response. This behavior is called synchronous because the computer performs
the written code line by line.

If you write the same type of code in JavaScript things are working differently. Let me explain why.
First of all pure JavaScript is single-threaded. Due to that fact it only has the possibility to perform
your code line by line, so to say JS code is executed synchronously. But this only applies to JS and not
for browser api calls. Imagine, if you perform an http request as I did in the example above, you call
functions from the browser api. At this point the JS engine can continue with the next statement (next
line of code) and the browser performs his task in the background. As soon as he is ready he gives you a
callback. This is due to the fact that a website always has to react e.g. for resizing. If this would not be
possible you would see an hourglass when connecting to a webserver (which lasts a bit) and your whole
web app would be frozen. I think you know the well known Blue circle of death from windows.

The reason in JS style

So what to do if you want to connect to a webserver? The thing is that you have to wait for the response
until you can continue your code. In JS the answer is splitted to three statements: async, await and
promises.

The concept behind this is that the promise which executes your code (e.g. pulling a webserver), has two
callback functions. One is called if everything was successful and the other handles possible errors. Maybe
it is better to give you a tiny example in JS:

...
let lPromise = new Promise(
  function(ASuccess, AFailed){
    setTimeout (
      function(){
        ASuccess("Waited 2 seconds") ;
      }, 2000);
    });
...

I created a promises which performs setTimeout() to wait for 2 seconds and then he calls the success
function.
The next step is that you can mark a function as async so that it returns a promise and no longer maybe
a string. This

...
async function MyAsyncFunction(){
  return "Hello World!" ;
}
...

is the same as

...
async function MyAsyncFunction(){
  return new Promise(
    function(ASuccess, AFailed){
	  ASuccess("Hello World!");
	});
}
...

I know this is hard to understand but please keep in mind that this is just another way to return a
promise but it is much more legible.

Calling this function with the await keyword makes sure that your code waits for the success callback
function of the returned promise and calculates the result of this function which can be the response of
the server. Think of the lPromise from above which simply waits 2 seconds. If I would run the following
lines of code

console.log("Before calling");

  let lPromise = new ...

console.log(await lPromise);

it would first print Before calling to the console and wait 2 seconds in order to print Waited 2
seconds.

Available in TMS WEB Core?

Sure, this is a great feature of JS and should be possible in TMS WEB Core to build modern web apps.
But it is not. So sorry, end of article.

No, just fun! Of course you can use it! The compiler magicians from the FPC community integrated this
for you.

How to use

The use of async and await are very similar to its usage in JS. I will start with the async identifier.
To convert a normal function to an async function you can do this:

function TMyObject.ThisMethodIsAsync: Integer; async;
begin
  ...
end;

or this, which is more readable and compilable by the Delphi compiler because he does not know the
async keyword:

TMyObject = class(TObject)
  [async]
  function ThisMethodIsAsync: Integer;
end;

...

function TMyObject.ThisMethodIsAsync: Integer;
begin
  ...
end;

The mindblowing effect on this async keyword is that ThisMethodIsAsync no longer returns an Integer
but now a TJSPromise! Remember, this is very similar to JS.

It is also possible to create this promise manually. This way you can call the success callback function
for returning your result. Technically this is the same but your code looks much more than Delphi code
if you use async. Look at this:

function TMyObject.ThisMethodIsAsync: TJSPromise;
begin
  Result := TJSPromise.new(
    procedure(ASuccess, AFailed: TJSPromiseResolver)
    begin
      ASuccess(7);
    end);
end;

This example just returns the value (7). One problem could be that now you cannot share this source code
between Delphi (maybe VCL) and TMS WEB apps because there is no TJSPromise in the VCL.
Well, now there is a tiny base for async calls because the promise has a success callback function. But
how to get the Result of async functions? Good question but as I said, this is very similar to JS, so we
can use await. Here’s the syntax:

procedure TMyObject.CallAsyncFunction;
var
  lBuffer: Integer;
begin
  lBuffer := await(ThisMethodIsAsync);
  ...
end;

In the lines below calling that async function, you can be sure that the result is stored in lBuffer and
there won’t be any callback function which returns later. If you want to have a look at more examples
please visit the Pas2JS homepage.

Compiler magic

If you want to write and compile your code in the Delphi IDE you should pay attention that the dcc
compiles your code (otherwise all of your code is marked red). Because of that the whole WEBLib exists
twice. One implementation is the real one which is executed in the browser (Core Source) and the other
one is for Delphi (Component Library Source). Of course you want to use programming assistance and
to give Delphi a break you should give him valid Delphi code so that he can make suggestions. E.g.
this is why I recommend you to use the async attribute. At this points the stub units in the “second”
WEBLib are used because all functions from the real one are defined here as well but in valid Delphi syntax.

But anyway, let’s have a concluding look at await. The thing is that Pas2JS recognizes async functions
as functions which return a promise, but Delphi thinks that it returns e.g. a string or an Integer.

Well, the TMS team dealt with making await Delphi conform and defined it in the stub units like this:

function Await(const AValue: string): string; overload;
begin
  Result := AValue;
end;

As you can imagine this only works for a finite amount of types (in this case primitive types like string
and Integer). So to say, if you create an async function which returns TMySpecialType the Delphi
programming assistance crashes because await is not defined for it whether it compiles with Pas2JS.
But the TMSWEBCompiler provides some compiler magic. It exists the following record in the unit
JS.pas (since I mean the stub unit it is located in the Component Library Source folder, not in the Core
Source folder):

TAwait = record
  public
    class function Exec<T>(const AValue: T): T; static;
    ...
end;

This allows you to write the following:

...
var
  lValue: TMySpecialType;
begin
  lValue := TAwait.Exec<TMySpecialType>(AsyncFunctionReturningThisType);
...

Internally this is only converted to

...
var
  lValue: TMySpecialType;
begin
  lValue := await(AsyncFunctionReturningThisType);
...

You should better use this generic method because this is compilable with Delphi and your programming
assistance keeps working.

Conclusion

So to say, we have found a possibility to “synchronize” our code but keep in mind that it is still asynchronous! The huge advantage of this is that your code becomes very legible (you will thank yourself in
the future) and you use the latest concepts of the JS engine, too!

Author: Leon Maximilian Kassebaum

Read More

Read More

TMS WEB Core for Visual Studio Code v1.2 released!

After we released TMS WEB Core v1.6 Pesaro for Delphi & Lazarus on earlier in January this year, we are pleased to inform that the release of TMS WEB Core for Visual Studio Code is now here as well. This brings the framework and language support on par with the versions for Delphi or Lazarus.

Focus on new language features

Among the major new capabilities of the pas2js compiler are:

  • Generics
  • Attributes
  • Class constructors
  • Resource strings
  • Async procedure decorator
  • Await support
  • JavaScript promises support
  • Resource file support

So, the long awaited support for generics (that comes with the accompanying RTL unit generics.collection) and attribute support will allow that nearly all of your existing Delphi code can move over to TMS WEB Core for creating web applications.

On the other side, the new support for async procedures, for promises and for await, will mean that you can use modern web paradigms for handling asynchronous functions easier. These features async, promise and await are direct equivalents to the existing JavaScript functionality and do not exist for native Delphi application development.

Updating is easy

Updating to the new TMS WEB Core for Visual Studio Code v1.2 is easy. Either you obtained TMS WEB Core for Visual Studio Code from the Microsoft marketplace and the IDE will handle the update automatically for you or you can download the latest version from our website. Either way, you will need to reactivate either your trial or full registered version credentials.

What’s next?

We have been working a long time on v1.2 but in parallel we have already made significant advances for the next release v1.3. The new version will bring component package support. So, from the IDE, you will be able to install additional component packages including creating your own custom component packages. When this is in place, your array of available components at design-time will rise significantly as our full range of TMS FNC Components will become readily available from TMS WEB Core for Visual Studio Code as well. For now, this use was limited to using the classes via runtime code.

Get started now

If you didn’t get your feet wet already with RAD component based Object Pascal based web client development, now is the time to enter this fast moving & fascinating world. The sheer amount of new possibilities and territories is staggering. You cannot only develop no-deployment cross platform rich web client applications, but also offline usable and installable PWA’s for use on mobile devices bypassing Apple or Google stores. Or you can use the Electron framework to create cross-platform desktop applications for Windows, macOS and Linux with a modern and fresh looking HTML/Web based GUI. And with Visual Studio Code, you can do all this directly from your favorite operating system: Windows, macOS or Linux.

Learn here about the new generics support:

Get the TMS WEB Core for Visual Studio Code v1.2 trial or use TMS WEB Core for Visual Studio Code v1.2 as part of the TMS ALL-ACCESS subscription, the no-nonsense subscription to our entire product portfolio coupled with priority technical support services.

Read More

Read More

WYSIWYG rich text editing in FMX

Intro

The multi-device, true native app platform
The FireMonkey® framework is the app development and runtime platform behind RAD Studio, Delphi and C++Builder. FireMonkey is designed for teams building multi-device, true native apps for Windows, OS X, Android and iOS, and getting them to app stores and enterprises fast.

source: https://www.embarcadero.com/products/rad-studio/fm-application-platform

FMX (FireMonkey) released in 2011 and shortly after we delivered a first set of components. Today, we want to show you the TTMSFNCRichEditor component, a light-weight WYSIWYG editor for formatted text.

Features

Below is a list of the most important features the TTMSFNCRichEditor has to offer. The features are not limited to this list, but this will give you a quick insight on what we offer to be able to edit and format rich text content in FireMonkey.

  • Formatted text with bullets, hyperlinks, images, indenting and aligned paragraphs
  • Functions for merging, highlighting text, undo/redo and clipboard operations
  • Horizontal ruler support
  • Stores its text natively in the .RTE file format
  • Possibilities to load from .TXT, .RTF, .HTML and .RTE
  • Export to .PDF, .TXT, .RTF, .HTML and .RTE
  • Separate rich editing/formatting toolbars
  • Emoticons support
  • Support for BitmapContainer images
  • Autocorrect: custom auto-correct actions
  • Interface to TMS Spell Check engine

Learn More!

Want to learn more about what the TTMSFNCRichEditor can do? Here is a video that highlights some of the above features through a demo application.

Download & Explore!

The TTMSFNCRichEditor component is part of the TMS FNC UI Pack, which, on top of FMX, also offers the ability to write your code once and target other frameworks (VCL, LCL and WEB). You can download a full featured trial version of the TMS FNC UI Pack and start exploring the capabilities of the TTMSFNCRichEditor component.

Coming up

The TTMSFNCRichEditor is the first of a series of components that is covered to empower your FMX (FireMonkey) developments. We started the series with a general overview of the most important components that we have to offer. Next up will be the TTMSFNCPlanner component, a highly configurable planner / scheduler component for FMX (FireMonkey), so stay tuned for more!.

Read More

Read More

TMS WEB Core v1.6 released

We’re thrilled to bring the quantum leap the pas2js v2.0 compiler brings to TMS WEB Core with the release of TMS WEB Core v1.6 Pesaro today.
The new compiler has been in development for quite some time and brings the experience for Object Pascal developers to create web client applications from the Delphi or Lazarus IDE to a new level. Among the major new capabilities of the pas2js compiler are:

  • Generics
  • Attributes
  • Class constructors
  • Resource strings
  • Async procedure decorator
  • Await support
  • JavaScript promises support
  • Resource file support

In a nutshell, this ensures you can bring your modern Object Pascal code to the web as well as take advantage directly from Object Pascal code from modern typical web paradigms such as await & promises for handling asynchronous code.

All active registered users for TMS WEB Core can obtain the update after login on our website under “My Products”. Just as our team internally can now start taking advantage of the new compiler features to write new & enhanced framework code, you can apply this to your application level code. The new compiler features will also enable more of other TMS products that were already using generics and attributes for example to become a possible target
for porting this to TMS WEB Core.

TMS FNC Products ready for the new TMS WEB Core

Note also that our entire TMS FNC components portfolio has already been prepared for compatibility with TMS WEB Core v1.6. The amazing array of cross-framework, cross-platform components from TMS FNC UI Pack, TMS FNC Chart, TMS FNC Cloud Pack, TMS FNC Maps, TMS FNC Blox, TMS FNC Dashboard Pack is ready for use in your web client applications now.

Coming soon to Visual Studio Code

As the same compiler and exactly the same framework code is used in TMS WEB Core for Visual Studio Code, you can expect shortly the release of TMS WEB Core for Visual Studio Code v1.2 that will bring all these enhancements to the Visual Studio Code IDE running directly on Windows, macOS or Linux.

It doesn’t end here, it just continues

With the new TMS WEB Core release, the path is now also open to start introducing new functionality and features at framework level. Our team has been very busy in parallel to develop new extensions to the framework, so, be assured that TMS WEB Core v1.7 is already in the pipeline. More about what is cooking in the labs for v1.7 will be detailed in the coming weeks.

Get started now

If you didn’t get your feet wet already with RAD component based Object Pascal based web client development, now is the time to enter this fast moving & fascinating world. The sheer amount of new possibilities and territories is staggering. You cannot only develop no-deployment cross platform rich web client applications, but also offline usable and installable PWA’s for use on mobile devices bypassing Apple or Google stores. Or you can use the Electron framework to create cross-platform desktop applications for Windows, macOS and Linux with a modern and fresh looking HTML/Web based GUI.
And know that we have even more and exciting alternative targets for TMS WEB Core web client applications in the making!

Learn here about the new generics support:

Get the TMS WEB Core v1.6 trial or use TMS WEB Core v1.6 as part of the TMS ALL-ACCESS subscription, the no-nonsense subscription to our entire product portfolio coupled with priority technical support services.

These are exciting times for Delphi, Lazarus or Object Pascal developers in general!

Read More

Read More

Simple FireMonkey 3D

Creating 3D software is undeniably cool, but it might be intimidating, what with all of the math and unfamiliar concepts. And the math... Fortunately, FireMonkey does a lot of the heavy lifting for us. You can get started while writing little or no code and still have the option of digging deeper when you need to. It's a familiar concept for Delphi developers. We'll create a simple FireMonkey
Read More

This was 2020 at TMS

There is a lot to say about this year 2020 and for sure, we at TMS had our challenges as well. But to end the year and look back at it, we prefer to stick to the positive things that happened this year.

New products

Looking back, it is actually amazing how many product releases we did and what significant new products were introduced. I think like most software developers, you can relate to the feeling how sometimes painfully slow and difficult software development can be. But in hindsight, we can look back at fantastic achievements. It is with this feeling I’m looking back at our year 2020 especially about two new products that were released:

TMS FNC Maps

We took our FNC concept on steroids with this new product. TMS FNC Maps is not only supporting 4 different development frameworks, 5 operating systems, all major browsers but also 8 different mapping services. Take the best mapping features at the best prices and combine these to integrate powerful mapping functionality in your VCL, FMX, LCL and TMS WEB Core web applications.

TMS WEB Core for Visual Studio Code

Another tour de force was bringing our TMS WEB Core framework to Visual Studio Code. Visual Studio Code is like a natural fit for TMS WEB Core. It is the beloved IDE for web developers, it runs on Windows, macOS and Linux, it is built with web technology, it has a large ecosystem and it is free. It foremostly enables to render your pages and its controls live in the designer, even taking responsive design in account. We even released already a major update in 2020 with support for PWA and Electron cross-platform desktop application development support. Upcoming is the release of v1.2 with support for pas2js v2.0 compiler that introduces generics, attributes, await, promises and many more new capabilities.

Product updates

Many products got constant updates mainly driven by your feedback, needs, requests. There are too many updates in 2020 to cover all in detail but I’d like to highlight a few ones that personally excited me.

TMS Flexcel

TMS Flexcel for VCL/FMX and TMS Flexcel for .NET got frequent updates this year. The major new features that were added are support for .NET Core v5.0 and an API for adding charts to .XLSX files.

TMS VCL UI Pack

Formerly known as TMS Component Pack, TMS VCL UI Pack has an almost bi-weekly update scheme. Countless new features and enhancements were added all the time. But for me, the major one is the introduction of the new TAdvWebBrowser component that is a wrapper for the new Windows Edge Chromium browser. TAdvWebBrowser permits modern and secure integration of web functionality in your VCL applications. Further, we focused a lot on polishing VCL styles support, TMS styles support and multi-monitor high-DPI support.

TMS FNC UI Pack

Be it for cross-platform FireMonkey applications, VCL Windows applications, TMS WEB Core web applications or free Lazarus IDE based cross-platform applications, TMS FNC UI Pack is a bundle of UI controls including grid, planner, rich editor, treeview, object inspector, … and much more.

Several new components were added to this pack this year: TTMSFNCWaitingIndicator, TTMSFNCSplitter, TTMSFNCRating, TTMSFNCRichEditorHorizontalRuler, TTMSFNCProgressBar and also here our cross-framework, cross-platform browser component was updated to Edge Chromium on the Windows platform. We also introduced FNC styles, to enable easily to give applications built with FNC UI controls a modern Microsoft Office or Microsoft Windows like look & feel.

TMS WEB Core

Two major releases of TMS WEB Core were done, TMS WEB Core v1.4 Ravenna and TMS WEB Core v1.5 Rimini bringing heaps of new functionality.

  • New UI components: TWebImageSlider, TWebContinuousScroll, TWebShare, TWebToast
  • New UI logic capabilities: TWebElementActionList, automatic theme adaption, Sentry based cloud exception logging
  • New support for DB backends: RAD server, FaunaDB, Dream Factory: TWebRadServerClientDataset, TWebDreamFactoryClientDataSet, TWebFaunaDBClientDataSet
  • New IDE integration: live preview, HTML template import
  • New direct local database access in Electron apps: mySQL and PostgreSQL

RAD Studio 10.4 support added

This year, Embarcadero released RAD Studio 10.4, so of course, we ensured that every product works seamlessly and as fast as possible with the newest IDE.

TMS Business Subscription

The suite of products to create powerful backends was non-stop improved and extended. TMS XData swagger support was enhanced and it got flexible URL routing mechanism using Route attribute. TMS Logging got support for the Linux platform and new logging output handlers. TMS RemoteDB got support for native database-access drivers, making you no longer depend on FireDac, UniDac or other drivers and have faster operation.

TMS Cryptography Pack

We delivered also here in 2020 several new cryptography functionality: New TLSH component for comparing files based on hashes, new key import from PEM files in TECCEncSign & TRSAEncSign, new signature algorithm on elliptic curve ed448.

Web site enhancements

We launched the TMS Support Center this year, replacing the old support forum. The TMS Support Center offers better search, better interface for editing posts, adding attachments to post, direct messages, … resulting in a much better experience for consulting our support. And best of all, we were able to import our old support forum information in the new TMS Support Center so no valuable information got lost.

We also overhauled the “My Products” page on our website. It became faster and gives you a more focused view on your active versus expired products, offers to renew and status of active licenses.

Academic program launch

We launched this year our TMS Academic Program. Its goal is to enable students to get the maximum out of Delphi and become a new generation of passionate Delphi developers this way. An academic version of the product is free and fully functional and supports the latest Delphi IDE. The program was started this year and we already brought academic versions of 4 of our major products: TMS VCL UI Pack, TMS FNC UI Pack, TMS WEB Core and TMS Flexcel for VCL/FMX.

Books

Four (yes 4!) books were released this year. It started in March with TMS WEB Core Webanwendungen mit Delphi entwickeln written by our chief evangelist Holger Flick and was followed quickly by the English version TMS WEB Core: Web Application Development with Delphi. These books get you started either in German language or English language to develop full web applications with TMS WEB Core clients and TMS XData based backends.

Later in the year, a first book in a series “Hands-on with Delphi”, the book “TMS Software Hands-on with Delphi: Cross-platform Multi-tiered Database Applications: Web and Desktop Clients, REST/JSON Server, and Reporting” was released. The goal of the hands-on series is to cover how different TMS products combined with Delphi fit together with real-life examples. In the first hands-on book, TMS FNC UI Pack controls, TMS Cryptography Pack, TMS Flexcel, TMS Aurelius ORM & TMS XData, TMS WEB Core are all used together.

And if that was not enough, even the 2nd in the series TMS Software Hands-on with Delphi was released: FNC Maps: Cross-framework, Cross-platform, Cross-service Mapping Component Library. This book mainly covers the new TMS FNC Maps product but brings TMS FNC UI Pack, TMS WEB Core, TMS Flexcel, TMS XData, TMS Cryptography Pack in the mix.

Celebrations

This year 2020, there was not only the celebration of 25 years Delphi in February but also 20 years founding of the company tmssoftware.com BV in October.

Consulting partners

This year, we also extended our family of partners around the world assisting Delphi developers to get the most out of Delphi in combination with TMS products. We welcome this year Thierry Laborde, offering consulting on Delphi & TMS products for the French speaking developer community and the company Abatic in Spain for the Spanish speaking Delphi developers. In addition to our existing partners, they can give you a helping hand in the most challenging parts of your software development with Delphi and our products.

Videos

Not only did our chief evangelist Holger Flick add numerous videos on our YouTube channel, in July our colleague Gjalt also started a new series Gjalt’s 101. With this new series, Gjalt brings you the latest news about what is cooking in our labs and tips & tricks to get the most out of our components.

2021 …

The new year is a white page. There is already lots in the pipeline, exciting R&D work that will come soon to existing and new products, new services we will bring and there are even more ideas and dreams. We are ready to make 2021 an exciting year for Delphi developers! We will share information about upcoming developments soon. We are foremost interested in hearing what your ideas, wishes, needs and dreams are, so our team efforts can maximally aligned to these!

Best wishes for a happy & healthy 2021!

Read More

Read More

Even empty applications have bugs

We were contacted by a person who claimed to have found a bug in EurekaLog. He justified this statement as follows: if you create a new DataSnap application and add EurekaLog to it, the application will crash with Access Violation on exit. The investigation revealed the following: The ServerContainerUnit1 data module contains a DSServer1 server component; The same data module contains two auxiliary components: DSTCPServerTransport1 and DSServerClass1; Both DSTCPServerTransport1 and DSServerClass1 specify the DSServer1 as a "Server"; When the application exits, the ServerContainerUnit1 data module will be destroyed; Destroying a data module means destroying all components inside - including DSTCPServerTransport1 and DSServerClass1. Here's where it happens: TDSServerClass.Destroy TComponent.DestroyComponents TDataModule.Destroy TDSTCPServerTransport.Destroy TComponent.DestroyComponents TDataModule.Destroy However, neither TDSServerClass.Destroy nor TDSTCPServerTransport.Destroy notify the server that they are being destroyed. As a result, DSServer1 continues to store reference to the (already deleted) DSTCPServerTransport1 and DSServerClass1; The ServerContainerUnit1 data module continues to clean up; It is now time to remove DSServer1. Specifically, the DSServer1 tries to stop all registered transports: TDSCustomServer.StopTransports TDSCustomServer.Stop TDSServer.Stop TDSServer.Destroy TObject.Free TComponent.DestroyComponents TDataModule.Destroy which will cause Access Violation, since the objects for these transports have already been deleted. As you can see, it is a bug in DataSnap, not in EurekaLog. EurekaLog only revealed this bug. Indeed, when EurekaLog is not enabled, DSServer1 can "successfully" call the StopTransports method, since memory of already deleted objects will not be changed, therefore calls of methods of already deleted objects inside StopTransports will be "successful". Note that this error has been sitting in DataSnap for ages and no one fixes it - precisely because there is no means to detect it in a naked application (without additional debugging tools). There are similar problems in the empty Fire Monkey (FMX) application, as well as in many standard Delphi components. Specifically, this error can be worked around if you force DSServer1 to be deleted first: procedure TServerContainer1.DataModuleDestroy (Sender: TObject); begin FreeAndNil (DSServer1); end; Other errors of a similar nature should be investigated separately. If you cannot fix the error, you can always turn off memory checks in EurekaLog, although this is not recommended. Read more stories like this one or read feedback from our customers.
Read More

ICS V8.65 announced

 ICS V8.65 has been released at: http://wiki.overbyte.eu/wiki/index.php/ICS_Download ICS is a free internet component library for Delphi 7, 2006 to 2010, XE to XE8, 10 Seattle, 10.1 Berlin, 10.2 Tokyo, 10.3 Rio and 10.4 Sydney, and C++ Builder 2006 to XE3, 10.2 Tokyo, 10.3 Rio and 10.4 Sydney. ICS supports VCL and FMX, Win32, Win64 and MacOS 32-bit targets. The distribution zip includes
Read More

FNC empowers your FMX (FireMonkey) development

Intro

The multi-device, true native app platform
The FireMonkey® framework is the app development and runtime platform behind RAD Studio, Delphi and C++Builder. FireMonkey is designed for teams building multi-device, true native apps for Windows, OS X, Android and iOS, and getting them to app stores and enterprises fast.

source: https://www.embarcadero.com/products/rad-studio/fm-application-platform

FMX (FireMonkey) released in 2011 and shortly after we delivered a first set of components. Through the years we learned and evolved our FMX support and translated that knowledge into new major components:

  • Grid
  • Planner
  • Treeview
  • Chart
  • Kanban Board
  • Pickers & Selectors
  • Rich Editor

All of these components fully adopted the FMX (FireMonkey) framework. In 2016 we even went a step further and introduced FNC. FNC boosts your FMX development and offers a single code base to re-use in other frameworks as well: VCL, WEB (TMS WEB Core) and LCL (Lazarus).

To the point

How FNC empowers your FMX development is nicely demonstrated and explained by Holger Flick in the following video. He explains the various components available for the FMX framework, how to use them and what they can do for your application.

Get started!

Get started exploring FMX and what FNC can mean for your FMX development: http://fnc.tmssoftware.com. Already using FNC? Let us know in the comments.

Read More

Read More