Category: Firemonkey

TMS FixInsight 2019.11

I'm happy to announce FixInsight 2019.11 release What's New * New : Rule W531 Actual parameter of FreeAndNil() must be a reference to class instance * New : Rule W534 Class instance passed but interface expected * Fixed : FixInsight hangs in some cases when running W525 * Fixed : File specified in {$INCLUDE} directive cannot be found in some cases * Fixed : Access Violation on IDE start * Fixed : "Load Defaults" button in Settings dialog doesn't restore general settings * Fixed : Several parser issues I'll add few more words about new features. Rule W531 ensures that the parameter of FreeAndNil() is be a reference to a class instance. Due to FreeAndNil() implementation details, compiler is not able to check its parameter type. This compiles, but this is wrong: var Intf: IInterface; begin FreeAndNil(Intf); end; Rule W534 ensures that a class instance is not passed when an interface is expected. This may compile, but due to reference counting a class can be released right after such method call. Example: type ISomeInterface = interface ['{AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA}'] end; TSomeClass = class(TInterfacedObject, ISomeInterface) end; procedure DoSomethingWithSomeInterface(const SomeInterface: ISomeInterface); begin // ... end; procedure DoSomethingWithSomeClass; var SomeClass: TSomeClass; begin SomeClass := TSomeClass.Create; try DoSomethingWithSomeInterface(SomeClass); // <= W534 // After this call SomeClass will be released due to reference counting finally SomeClass.Free; // cannot be released twice end; end; Also there are new parameters for command line tool. In this release FixInsight needs to know more about your project. FixInsightCL --project=c:\source\example.dpr --libpath="C:\Program Files (x86)\Embarcadero\Studio\20.0\source" --unitscopes=Winapi;System.Win;Data.Win;Datasnap.Win;Web.Win;Soap.Win;Xml.Win;Bde;System;Xml;Data;Datasnap;Web;Soap --libpath should point to your Delphi source folder. And I suggest to copy values for --unitscopes and --unitaliases parameters from your project options.
Read More

TMS WEB Core v1.3 features part 2 of 2

A couple of days ago, we wrote a first blog article about the new features coming in TMS WEB Core v1.3.
If you were not already stunned by the first 10 new features presented for TMS WEB Core v1.3 Ferrara, here are 10 more new features:

1) Web crypto API wrapper classes

The web crypto API is meanwhile also standard built-in in all modern browsers. Therefore, for your convenience, easy to use Pascal wrapper classes are now provided that allow you to take advantage from these APIs from your code. This includes AES & RSA encryption as well as RSA & HMAC signature generation.

  • TAESEncryption
  • TRSAEncryption
  • TRSASignature
  • THMACSignature

2) Regular expression API wrapper class TRegEx

Browsers did have regular expression handling functionality for a long time. To make this easy to use for Delphi developers, we created a TRegEx class with an almost identical interface to the Delphi TRegEx class for maximum code reusability.

3) Local file access via TWebFilePicker, TWebFileUpload

TWebFilePicker is a component to let you pick local files via an open dialog while TWebFileUpload lets you do the same but in addition also enables to drag files from the machine file explorer to the browser. The components TWebFilePicker, TWebFileUpload have been extended to offer access to the properties of the selected local files as well as get the data of the file(s) in text, base64, URL or byte array format.

4) TWebLookupComboBox, TWebDBLookupComboBox

Having a combobox with two values per item, a displayed value and a data value is often a requirement for UI logic. With TWebLookupComboBox and its DB-aware counterpart TWebDBLookupComboBox, this is now out of the box available. Simply set & retrieve both the display value and data value per item.

5) Redesigned TWebMainMenu

Previously, the VCL TMainMenu equivalent for the web uses the jqWidgets controls by default. While the jqWidgets menu is nice & powerful, we thought it was better to have a menu component in the base controls and a separate one that is based on jqWidgets for those who need extra features. The new TWebMainMenu however brings all the convenience of the VCL TMainMenu and in addition has built-in responsive design. That means, if the width of the menu becomes too wide, it will collapse automatically and behave as a hamburger menu.

6) New features for TWebGoogleMaps

A lot of Google Maps functionality that was already available in our VCL TWebGMaps or FMX equivalent for a long time has now been added to TWebGoogleMaps. Adding circles, lines, rectangles, polygons, polylines is now possible. Selecting themes, load GPX files, use KML layers is easily accessible by calling simple TWebGoogleMaps methods.

7) New TWebImageZoomControl

An often used paradigm in web applications is the display of a thumbnail and showing the large version of the image when it is clicked. We have nicely encapsulated this functionality in the TWebImageZoomControl. With this control, it is as easy as setting the thumbnail image URL and large image URL and the control does everything for you.

8) Support for selecting the Electron version

With frequent new releases of the Electron framework for building cross platform desktop applications from your web applications, controlling which version of Electron to use became hard. Now, with a setting under project options, it is easy to select with what version of Electron you want to package your application (if multiple Electron versions are installed on your machine).

9) Component attribute for JS & CSS lib dependencies

TMyDependentComponent = class(TCustomControl);

This is a feature that will please developers diving into custom control development for TMS WEB Core. Often, a custom control can have a dependency to an external JavaScript and/or CSS library. When one uses the control but forgets to include the references to these external libraries, the control will normally not work. To avoid this, a new attribute was provided and the attribute parameters hold one or more external library references. When such control is added to the project, the library references will be automatically added to the project HTML file.

10) Update to latest pas2js compiler and pas2js RTL

We have included the latest pas2js compiler release version and updated to the latest RTL source. This way you can take advantage of all latest releases of the open-source pas2js project.

Our team is working hard doing the last finishing touches on the v1.3 release which is around the corner. Active TMS WEB Core users and TMS ALL-ACCESS users will get a notification shortly that the new version is available from the account page on our website.

Read More

Read More

FMX Android TControl.MakeScreenShot or TCanvas.FillText always generate black block around fonts

I want to create a picture with "white background and black labels" and share it using intent. But my picture always generate black block around all fonts. It's been 2 days now I'm stuck on this problems. Anybody has solution or can point me to the right direction? or any workaround if it's still a bug from developer? I'm using 10.2 Thank you. Edit: Adding example Code unit UTest; interface uses System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants, FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs, FMX.StdCtrls, FMX.Objects, FMX.Controls.Presentation; type TFTest = class(TForm) Rectangle1: TRectangle; Label1: TLabel; Label2: TLabel; Label3: TLabel; Image1: TImage; Button1: TButton; Button2: TButton; Image2: TImage; Button3: TButton; Button4: TButton; procedure Button1Click(Sender: TObject); procedure Button3Click(Sender: TObject); procedure Button2Click(Sender: TObject); procedure Button4Click(Sender: TObject); private { Private declarations } public { Public declarations } end; var FTest: TFTest; implementation {$R *.fmx} Uses System.IOUtils; procedure TFTest.Button1Click(Sender: TObject); begin Image2.Bitmap := Rectangle1.MakeScreenshot; end; procedure TFTest.Button2Click(Sender: TObject); var mrect:trect; begin Image1.Bitmap.SetSize(Trunc(Image1.Width * Image1.Canvas.Scale), Trunc(Image1.Height * Image1.Canvas.Scale)); Image1.bitmap.Canvas.BeginScene; Image1.Bitmap.canvas.Clear(TAlphaColors.White); Image1.bitmap.Canvas.Stroke.Thickness := 1; Image1.bitmap.Canvas.Stroke.Color := TAlphaColorRec.Black; Image1.Bitmap.canvas.Stroke.Kind := TBrushKind.bkSolid; Image1.bitmap.Canvas.Fill.Color := TAlphaColors.Black; Image1.Bitmap.Canvas.Fill.DefaultColor:=TAlphaColors.White; Image1.Bitmap.Canvas.Font.Size:=10; Image1.Bitmap.Canvas.Font.Family:='Arial'; Image1.Bitmap.Canvas.Font.Style:=[TFontStyle.fsbold]; Image1.bitmap.canvas.Blending:=false; Image1.Bitmap.Canvas.DrawLine(PointF(20, 10), PointF(330, 10), 1); mRect.Create(20, 10, 180, 30); Image1.bitmap.Canvas.filltext(mRect, 'DD:MM:YY HH:MM', false, 0, [],TTextAlign.Leading, TTextAlign.Center); mRect.Create(180, 10, 330, 30); Image1.bitmap.Canvas.filltext(mRect, 'SHID/CNAME', false, 1, [],TTextAlign.Trailing, TTextAlign.Center); Image1.Bitmap.Canvas.DrawLine(PointF(20, 30), PointF(330, 30), 1); Image1.bitmap.Canvas.EndScene; {$IFDEF ANDROID} image1.bitmap.SaveToFile(TPath.GetHomePath() + TPath.DirectorySeparatorChar + 'screenshot.jpg'); image2.Bitmap.LoadFromFile(TPath.GetHomePath() + TPath.DirectorySeparatorChar + 'screenshot.jpg'); {$ENDIF} {$IFDEF MSWINDOWS} image1.Bitmap.SaveToFile('E:\screenshot.jpg'); image2.Bitmap.LoadFromFile('E:\screenshot.jpg'); {$ENDIF} end; procedure TFTest.Button3Click(Sender: TObject); var bmp: TBitmap; begin bmp := TBitmap.Create; bmp.Width := Image2.bitmap.Width; bmp.Height := Image2.bitmap.Height; bmp := Rectangle1.MakeScreenshot; {$IFDEF ANDROID} bmp.SaveToFile(TPath.GetHomePath() + TPath.DirectorySeparatorChar + 'screenshot.jpg'); image2.Bitmap.LoadFromFile(TPath.GetHomePath() + TPath.DirectorySeparatorChar + 'screenshot.jpg'); {$ENDIF} {$IFDEF MSWINDOWS} bmp.SaveToFile('E:\screenshot.jpg'); image2.Bitmap.LoadFromFile('E:\screenshot.jpg'); {$ENDIF} end; procedure TFTest.Button4Click(Sender: TObject); begin image1.Bitmap := nil; image2.Bitmap := nil; end; end. Form object FTest: TFTest Left = 0 Top = 0 Caption = 'Form1' ClientHeight = 530 ClientWidth = 360 FormFactor.Width = 320 FormFactor.Height = 480 FormFactor.Devices = [Desktop] DesignerMasterStyle = 3 object Rectangle1: TRectangle Fill.Color = claWhite Position.X = 8.000000000000000000 Position.Y = 8.000000000000000000 Size.Width = 345.000000000000000000 Size.Height = 121.000000000000000000 Size.PlatformDefault = False Stroke.Kind = None object Label1: TLabel Align = Top Size.Width = 345.000000000000000000 Size.Height = 23.000000000000000000 Size.PlatformDefault = False TextSettings.HorzAlign = Center Text = 'Label1' TabOrder = 0 end object Label2: TLabel Position.X = 23.000000000000000000 Position.Y = 80.000000000000000000 Text = 'Label2' TabOrder = 1 end object Label3: TLabel Position.X = 23.000000000000000000 Position.Y = 48.000000000000000000 Text = 'Label3' TabOrder = 2 end end object Image1: TImage MultiResBitmap = Position.X = 8.000000000000000000 Position.Y = 136.000000000000000000 Size.Width = 345.000000000000000000 Size.Height = 121.000000000000000000 Size.PlatformDefault = False end object Button1: TButton Position.X = 8.000000000000000000 Position.Y = 264.000000000000000000 Size.Width = 345.000000000000000000 Size.Height = 44.000000000000000000 Size.PlatformDefault = False TabOrder = 2 Text = 'TLayout.MakeScreenShot (No Saving)' OnClick = Button1Click end object Button2: TButton Position.X = 8.000000000000000000 Position.Y = 360.000000000000000000 Size.Width = 193.000000000000000000 Size.Height = 44.000000000000000000 Size.PlatformDefault = False TabOrder = 3 Text = 'TCanvas.FillRect' OnClick = Button2Click end object Image2: TImage MultiResBitmap = Position.X = 8.000000000000000000 Position.Y = 408.000000000000000000 Size.Width = 345.000000000000000000 Size.Height = 121.000000000000000000 Size.PlatformDefault = False end object Button3: TButton Position.X = 8.000000000000000000 Position.Y = 312.000000000000000000 Size.Width = 345.000000000000000000 Size.Height = 44.000000000000000000 Size.PlatformDefault = False TabOrder = 5 Text = 'TLayout.MakeScreenShot (Saving)' OnClick = Button3Click end object Button4: TButton Position.X = 208.000000000000000000 Position.Y = 360.000000000000000000 Size.Width = 137.000000000000000000 Size.Height = 44.000000000000000000 Size.PlatformDefault = False TabOrder = 6 Text = 'Image NIL' OnClick = Button4Click end end On windows everything is normal, but when i run it on android: TLayout MakeScreenShot without saving has gray block around fonts. TLayout MakeScreenShot with saving has black block around fonts. TCanvas FillRect has black block around fonts. Canvas FillText
Read More

Problem displaying items in Listbox and Memo in Firemonkey Android application

I am at my first experiences with Android development using Delphi/Firemonkey 10.3.1 and have encountered the following problem with populating and displaying items in a TListbox component and a TMenu component at run time. I have placed TListbox and TMenu components on a panel, together with a button to trigger the generation of a sequence of random numbers and display them in these components. The TListbox component contains objects of class TListboxItemRandomNo descending from TListboxItem. The code for this class is: TListboxItemRandomNo= class(TListboxItem) private FRandomNo: integer; {Number displayed by Listbox item} protected procedure HandlePaint(Sender: TObject; Canvas: TCanvas; const ARect: TRectF); function GetItemText: string; public constructor Create(Owner: TComponent; RandomNoValue: integer); property RandomNo: integer read FRandomNo; end; constructor TListboxItemRandomNo.Create(Owner: TComponent; RandomNoValue: integer); var Listbox: TListbox; begin Listbox:= Owner as TListbox; inherited Create(Owner); Listbox.AddObject(Self); {Save RandonNo:} FRandomNo:= RandomNoValue; {Assign OnPaint event handler:} OnPaint:= HandlePaint; end; procedure TListboxItemRandomNo.HandlePaint(Sender: TObject; Canvas: TCanvas; const ARect: TRectF); var Text: string; TextSize: TSizeF; TextPosn: TPointF; TextRect: TRectF; begin {Calculate item text:} Text:= GetItemText; {Set colour for text:} Canvas.Fill.Color:= TAlphaColorRec.Black; {Determine text image size, position and bounding rectangle:} Canvas.TextWidth(Text); Canvas.TextHeight(Text); TextPosn.x:= ARect.Left + 5; TextPosn.y:= (ARect.Top + ARect.Bottom -; TextRect.TopLeft:= TextPosn; TextRect.Right:= ARect.Right; TextRect.Bottom:= TextRect.Top +; {Draw item text:} Canvas.FillText(TextRect, Text, False, 1.0, [], TTextAlign.Leading, TTextAlign.Center); end; function TListboxItemRandomNo.GetItemText: string; begin Result:= IntToStr(Index) + ': ' + IntToStr(FRandomNo); end; Initially I put the code to generate and display the random numbers in the OnClick event handler of the button. Whilst this approach worked on the Windows 32-bit platform, on the Android platform in both the TListbox and the TMemo components the items were not displayed. I then created an Action called ActionCalcRandomNos and moved the code to generate and display the random numbers from the button’s OnClick event handler into the OnExecute event handler of the action. I disconnected the OnClick event handler of the button and assigned ActionCalcRandomNos to it instead. After these changes I found that the items in both the TListbox and the TMemo components were displayed on both the Windows-32 and the Android platforms. The code in question is: procedure TForm1.ActionCalcRandomNosExecute(Sender: TObject); {Calculates a random sequence of numbers and displays them in TListbox and TMemo components} var i: integer; xi: integer; ListboxItemRandomNo: TListboxItemRandomNo; LineI: string; begin {Read number of random numbers required:} FRandomNoCount:= StrToInt(EditItemCount.Text); SetLength(FRandomNoSequence, FRandomNoCount); {Generate random number sequence:} Randomize; for i := 0 to FRandomNoCount-1 do begin xi:= Random(FRandomNoCount); FRandomNoSequence[i]:= xi; end; {Generate Listbox items dislaying random numbers:} ListBoxRandomSequence.Clear; ListBoxRandomSequence.BeginUpdate; for i:= 0 to FRandomNoCount-1 do begin ListboxItemRandomNo:= TListboxItemRandomNo.Create(ListBoxRandomSequence, FRandomNoSequence[i]); end; ListBoxRandomSequence.EndUpdate; {Write random numbers to TMemo:} MemoRandomNos.Lines.Clear; MemoRandomNos.BeginUpdate; for i:= 0 to FRandomNoCount-1 do begin LineI:= (ListBoxRandomSequence.ListItems[i] as TListboxItemRandomNo).GetItemText; MemoRandomNos.Lines.Add(LineI); end; MemoRandomNos.EndUpdate; end; Why did this code not work when called directly from the button OnClick event handler, but did work when called indirectly via the action ActionCalcRandomNos connected to the button? The only remaining minor problem with the TListbox is this. The item height, which is set as 0 in the Object Inspector, on the Android platform version only is being displayed much too great. This started after I changed the ItemHeight property back to 0 after previously having set it at 20. Any light shed on any of these problems would be helpful.
Read More

Why isn’t InputQuery returning bool?

I've followed the clear documentation to implement an input dialog box. It works fine. But, now i want to ignore the user input if they click cancel. Below is quote from that documentation. "If the user clicks the OK button, InputQuery returns True; InputQuery returns False otherwise." So, i tried the following code and the error i'm getting is E2034 Cannot convert void to bool when i run on Win32 and bccaarm error 1711 value of type void is not contextually convertible to bool on Android. if (InputQuery(caption, Prompts, sizeof(Prompts)/sizeof(Prompts[0]) - 1, Defaults, sizeof(Defaults)/sizeof(Defaults[0]) - 1, (TInputCloseQueryProc *)Met)){ // clicked OK } else { // clicked cancel } How can i test if OK or Cancel clicked? Below is the declaration for InputQuery and it should be bool. I'm confused. extern DELPHI_PACKAGE bool __fastcall InputQuery _DEPRECATED_ATTRIBUTE1("Use FMX.DialogService methods") (const System::UnicodeString ACaption, const System::UnicodeString *APrompts, const int APrompts_High, System::UnicodeString *AValues, const int AValues_High, const _di_TInputCloseQueryFunc ACloseQueryFunc = _di_TInputCloseQueryFunc())/* overload */;
Read More

Using the GetClass function with VCL / FMX not found

I have the following situation, project in *.bpl VCL structure. I want to adapt a screen made in FMX in this structure using LoadPackage and GetClass.

When I run form VCL after running FMX it loses reference in the GetClass function. But it can return the address that was allocated in the LoadPackage function. I couldn’t see what might be going on.

If anyone has an idea of ​​what might be happening or has been through it.


In untFormFMX.pas



In VCLForms.pas



In untPrinc.pas

procedure OpenFMXForm;
  oFMXForm: TForm;
  oFMXClass: TPersistentClass;
  oFMXClass := GetClass('TForm1');
  Application.CreateForm(TFormClass(oFMXClass) ,oFMXForm );

procedure OpenVCLForm;
  oVCLForm: TForm;
  oVCLClass: TPersistentClass;
  oVCLClass := GetClass('TForm2');
  Application.CreateForm(TFormClass(oVCLClass) ,oVCLForm );


1° Open VCL Form: OK
2° Open FMX Form: OK
3° Open VCL Form: not found return nil

Read More

Read More

Preview of TMS WEB Core for Visual Studio Code

At the TMS Training Days in Düsseldorf, Germany as well as at the Be-Delphi conference in Belgium, José León Serna (creator of Delphi for PHP & former Embarcadero IDE lead architect) gave a presentation previewing TMS WEB Core for Visual Studio Code. After more than a year of hard work & intensive collaboration with the TMS team, we were proud to present this technology preview with an almost complete feature set for the first release.

What is Visual Studio Code?

For software developers not familiar with Visual Studio Code, this is a free, open-source, extensible and cross-platform IDE. This means that the Visual Studio Code IDE works exactly the same on Windows, macOS and Linux and this also with full high-DPI support. Visual Studio Code is an initiative from Microsoft and focuses on being open & extensible. It is open source and fully free and is not to be confused with the regular Microsoft Visual Studio IDE. There is meanwhile a very rich offering of extensions for Visual Studio Code with numerous programming languages supported and all kinds of interesting IDE tools, utilities, convenient extensions. Last we looked, almost 3000 such extensions can be found at

What does TMS WEB Core for Visual Studio Code bring to the table?

As far as we know, at this moment nor Visual Studio Code nor any of its extensions provides a RAD, component based approach with a visual form designer. As this has always been at the heart of what Delphi means to Object Pascal developers, TMS WEB Core for Visual Studio Code brings a RAD component based experience with form designer, tool palette, object inspector, structure pane. In other words, it enables the Delphi or Lazarus developers to work on TMS WEB Core web client projects in pretty much the same way from Visual Studio Code.

Why the choice for Visual Studio Code?

Live data and live a bootstrap theme used in the form designer in Visual Studio Code

Live Google Maps in the form designer in Visual Studio Code

The reason for our efforts to develop a TMS WEB Core for Visual Studio Code is purely technology driven. Visual Studio Code itself is built using web technology. The Visual Studio Code UI is all rendered using HTML/CSS/JavaScript via the Chrome browser engine. This opens the fantastic opportunity to build a form designer from web technology, meaning that from the form designer, we can see the TMS WEB Core web components as-is or WYSIWYG. Where in the Delphi IDE the form designer is a VCL form designer and at design-time the web components are mimicked as VCL controls, here we have the real web component rendered in the form designer just like it will be rendered in the browser when the application is generated. Even at design-time, a CSS library such as Bootstrap can be used and it will show the controls on the form designer using the selected Bootstrap classes/themes. Of course, the fact that the IDE itself is free, light, fast, modern and that it runs on Windows, macOS, Linux is a fantastic & welcome additional benefit. Another not to be overlooked technical advantage is that Visual Studio Code has bindings to make it easy to debug Object Pascal code from the IDE (as opposed to debugging JavaScript code from the browser console).

Debugging a TMS WEB Core application directly from the Visual Studio Code IDE


The OmniPascal Visual Studio Code extension already brings excellent Object Pascal syntax highlighting, code completion, class completion and several more features for code editing. An interesting tidbit is that OmniPascal internally uses the Delphi AST engine, written by our colleague Roman Yankovski, product manager of TMS FixInsight. Of course, another prerequisite is the pas2js compiler. This is the compiler that brings the magic of compiling (or transpiling if you prefer this terminology) the Object Pascal code to JavaScript in the browser. This means that as Delphi developers, anything that happens in the browser, is under control of our beloved language. Fortunately, the TMS WEB Core for Visual Studio Code extension is developed in such way that these prerequisites are fully automatically installed in the IDE.

How does it compare with TMS WEB Core for Delphi or Lazarus?

The good news here is that the full TMS WEB Core framework works unchanged under Visual Studio Code. So, there is full framework feature parity between Delphi, Lazarus & Visual Studio Code. We also set it as a development requirement to offer the ability to open up Delphi created TMS WEB Core projects from Visual Studio Code and vice versa. As TMS WEB Core for Visual Studio Code uses the exact same framework code as Delphi, this means that whenever we add features or improvements to the Delphi product, this will be automatically adopted in the Visual Studio Code version. The reverse is of course also true.

What does this mean for TMS WEB Core for Delphi?

TMS WEB Core for Visual Studio Code is not a replacement for TMS WEB Core for Delphi. It is nothing more and nothing less than another IDE choice. We believe in freedom of choice. So, every developer can decide for himself what the preferred IDE is, be it Delphi, Lazarus or Visual Studio Code. Of course, the fact that Visual Studio Code & Lazarus are cross platform, i.e. can be used directly from macOS or Linux can be a deciding factor. Other than this, Delphi is used for way more than just developing TMS WEB Core web client applications, for example the development of a TMS XData or Embarcadero RAD server REST back-end. It is our hope actually that offering the Delphi RAD OO component based development for the Visual Studio Code community and showing the advantages it can bring, will attract these users also to Delphi!

What about the TMS FNC UI Controls that also work with TMS WEB Core?

TMS FNC Planner in a TMS WEB Core application in Visual Studio Code

Also here good news! TMS FNC Controls will also work fine from Visual Studio Code! There is also in TMS WEB Core for Visual Studio Code a mechanism for installing additional components. As such, you can also install TMS FNC controls in Visual Studio Code and benefit from all the power these controls bring! This makes the power of TMS FNC meanwhile staggering & mind-blowing. The FNC controls can be used in VCL Windows applications, FMX Android, macOS, iOS, Windows, Linux applications, LCL Windows, macOS & Linux applications, TMS WEB Core web applications for any HTML5 compliant browser from Delphi, Lazarus and Visual Studio Code.

Does TMS WEB Core also work with Visual Studio Online?

I know it gets boring, but this is another yes. Visual Studio Online is in beta right-now and promises to bring an IDE in the cloud. An IDE you can simply use from the browser. Anywhere, anytime, any machine with a browser can be used to develop, develop, develop … (I hear Steve Ballmer somewhere here).
So yes, we have tested TMS WEB Core with Visual Studio Online and also from the browser, it is possible to create web client applications for the browser. The circle is closed also in this area.

And what about the licensing?

We are strong believers in the KISS principle. So, to keep it simple, there will be just one TMS WEB Core license! Yes, you read that good. When you have a TMS WEB Core license, you decide in what IDE to use the framework or you can simultaneously use this in multiple IDEs. Delphi licensed TMS WEB Core users will be able to explore how things work in the Visual Studio Code IDE, on Windows or macOS or Linux or multiple operating systems. Visual Studio Code users might be tempted to try out TMS WEB Core with a Delphi Community or full edition and use the extra benefits Delphi brings, for example to build the back-end.

A TMS WEB Core Delphi sample project in Visual Studio Code on Linux

A TMS WEB Core Delphi sample project in Visual Studio Code on macOS

I’m blown away, I want it now!

We fully understand. This was/is the most mind-blowing development project in the 24 year history of TMS software. Never before we heard so much ‘wow’ sounds when our developers in our team were progressing step by step to build this magic. The audience in the TMS Training Days Düsseldorf and Be-Delphi conference in Belgium were also flabbergasted. Well, we are working extremely hard to bring a first beta in your hands. Let there be no misunderstanding, there is still more work & more polish needed before that milestone is reached. This is what our team now wants to fully focus on in the coming weeks. When we feel confident our baby will be safe in your hands, we will roll-out a beta soliciting your feedback. Our TMS ALL-ACCESS users will be the first to receive this beta. We will send out notifications when this is ready. Our aim is to bring a nice XMas present for you this year, but of course this is subject to change. The main criteria will be that the entire team is confident about the quality of the beta. At TMS, we don’t like the fetish of fixed dates for releases.


Our team already has ideas for further developments in several directions. So, sure, after a first release, we already have further exciting developments on our list. But foremost, we would love to hear from you what extra features, future directions you would like to see for this project. Contact us or leave a comment here!

Read More

Read More

Hardware Locked Licensing Delphi RIO

i want my user to use my software only in one system or login once at a time for that i want to know how can i create such keys that's effected by changes in other hardware. I am using that key to check in server and return true if the key generated by user hardware is same as key stored at first login from my desktop app. and at logout i am deleting that key from server and saving the key which will be fetched from next login hardware.. I've read all the related question but they are useless when any part of hardware is changed(such as hdd changed). and i know that this thing is not 100%. Is key based on bios is good alternative to hdd cpu and other components as they may change anytime ? i found this for delphi but this is way back updated and supported in windows 7 don't know about Windows 10.
Read More

how to configure tls on Delphi TRestClient component

Helo, I typed the code as follows and this code works well. By using an https connection I hope that the Packet Data received cannot be read by applications such as Wireshark or the Packet Capture application on Android. how do you configure the client side? this my code procedure TForm1.Button1Click(Sender: TObject); var MyCompletionHandler: TCompletionHandler; MyErrorCompletionHandler: TCompletionHandlerWithError; begin ShowLoadingIndicator(Self, True); Memo1.Lines.Clear; RESTClient1.BaseURL := ''; RESTClient1.RaiseExceptionOn500 := False; RESTClient1.SecureProtocols := [THTTPSecureProtocol.TLS12]; RESTRequest1.ClearBody; RESTRequest1.Resource := 'api/users'; MyCompletionHandler := procedure var i: Integer; tJson: TJSONValue; begin Label1.Text := 'Complete!'; Memo1.Lines.Append('Header: '); for I := 0 to RESTResponse1.Headers.Count-1 do Memo1.Lines.Append(RESTResponse1.Headers.Strings[I]); Memo1.Lines.Append(''); Memo1.Lines.Append('Body:'); tJson := TJSONObject.ParseJSONValue(RESTResponse1.Content); try memo1.Lines.Append(REST.Json.TJson.Format(tJson)); finally FreeAndNil(tJson); end; HideLoadingIndicator(Self); end; MyErrorCompletionHandler := procedure(AObject: TObject) begin Label1.Text := 'Error!'; HideLoadingIndicator(Self); end; RESTRequest1.ExecuteAsync(MyCompletionHandler, True, True, MyErrorCompletionHandler); end; result packet capture using app and this simple apps made with firemonkey: Simple Apps
Read More

10.3.3 Rio: Первые впечатления о новой версии RAD Studio

Полагаю, что все уже знают о выходе новейшей версии Embarcadero RAD Studio - 10.3.3 Rio и получили одно, два или даже больше электронных писем об этом в свой почтовый ящик. Официальное сообщение (10.3.3 Press Release) можно прочитать здесь: http...(read more)
Read More