Dimensional Data

There is a very exciting improvement in Delphi, C++Builder and RAD Studio 11.0 Alexandria: the IDE now fully supports high DPI scaling on high-resolution screens. This means that if you use Windows and have a 4K or similar high-res display, the IDE will render crisply and clearly on your screen. In fact, if you have two screens with different scales, you can have different IDE windows on those multiple displays and each will render perfectly, crisp and clear, on each monitor. This high DPI scaling support using the VCL’s own support for perMonitorv2 scaling, which we introduced a couple of releases ago, plus our own image collection and virtual image list components. In other words, we use the same tools we make available to you. Importantly, high DPI support includes support in the code editor, for crisp text, and when designing forms, both VCL and FMX. (If you’ve started RAD Studio 11 and thought, ‘hey, my form is small!’ read onwards – we have settings controlling the scaling in the VCL form designer and you’re set to unscaled by default.) Let’s dig into how the IDE behaves on both high-res and low-res displays today, some interesting notes about how it was implemented, and look at VCL form designing in particular. High DPI Comparison The best way to see the difference in the IDE is to use it. Using the IDE on a high-res display is like night and day – there are some things that screenshots only half convey, and what the RAD Studio 11 look and feel is like is one of them. In person, it’s an amazing difference. Here is a great image Jim McKeeth created comparing the 10.4.2 and 11.0 IDEs: On the left, the old DPI-unaware IDE in 10.4.2. It draws low-res, so is blurry when scaled up.On the right, the new high-DPI aware IDE in v11. It is crisp and clear no matter how high the scaling. You can see that the image on the right, in v11.0 Alexandria, the text and icons are clear no matter how large the display the IDE is placed on. Background – why High DPI? 2x the pixel density A typical scale set in Windows today is 200%. This is 2x the pixel density, which really means that for each pixel in the past, there are now four pixels (it is divided into two vertically and horizontally.) I am writing this on a 4K monitor, which is 2160 pixels high. That is 2 times 1080, a vertical resolution that before high DPI I used for years. To get everything to appear the same physical size onscreen, I need to scale by 2. If an app doesn’t support high DPI (is ‘DPI unaware’), Windows will scale it up, but upscaling adds blurriness. It is much better if an app is aware of the scaling applied to the screen its window(s) are on and can draw crisply. We added support to the VCL for this in 10.3, supporting perMonitorv2 high DPI scaling (the latest and best of the options Windows provides) and adding in components for high-res icons and image drawing, providing better support for high-res images in toolbars and menus that Windows has inbuilt. The IDE, which is mostly built with the VCL, uses these and is a great demo […]

Wouldn’t it be nice to have Stock Data Real-Time, Intraday & Historical Market information for your business and be able to instantly retrieve up-to-date data for any ticker down to the minute, request intraday quotes or search 30+ years of accurate historical market data? The stockmarket API is capable of delivering accurate data for 170,000+ worldwide stock tickers, from more than 50 countries, as well as 750+ market indices, information about timezones, currencies, collected from 70 global exchanges, including Nasdaq, NYSE, and more. In this article we will see how fast and easy it is to use RAD Studio and Delphi to create a Firemonkey multidevice application using the LowCode Wizard in addition to a REST client library to take advantage of market stack API and retrieve a JSON format response for stock market data in real-time. Our RAD Studio and Delphi applications will be able to call the API and request information based on the name of parameters you provide. How do I set up the MarketStack API? Make sure you refer to MarketStack API website (https://MarketStack.com/) and and sign up for the free plan providing only your email and some basic information (no credit card required). Once you are in the website will redirect you to a quick start guide dashboard and your API Access Key will be provided. The Access Key unique, personal and is required to authenticate with the API. Keep it safe! How do I call MarketStack API endpoints? Now all we need to do is to call the API base URL (http://api.marketStack.com/v1/) via a HTTP POST method with no JSON request body needed and some few requested parameters added to the URL address depending on the ednpoint we choose to call. One can do that using REST Client libraries available on several programming languages. marketStack offers several API endpoints to choose from: End-of-Day Data: Get daily stock market data. Intraday Data: Get intraday and real-time market data. Tickers: Get information about stock ticker symbols. Exchanges: Get infotmation about all supported exchanges. Currencies: Get information about all supported currencies. Timezones: Get information about all supported timezones. Our demo will focus on the End-of-Day endpoint but all the others follow similar logic but with different parameters passed. For a complete and detailed list of endpoints and its parameters make sure you refer to MarketStack Quickstart guide (https://marketStack.com/quickstart) // Intraday Data API Endpoint http://api.marketstack.com/v1/eod ? access_key = YOUR_ACCESS_KEY & symbols = AAPL // optional parameters: & interval = 1h & sort = DESC & date_from = YYYY-MM-DD & date_to = YYYY-MM-DD & limit = 100 & offset = 0 // more parameters available please refer to the API Documentation (https://marketStack.com/documentation) // Intraday Data API Endpoint http://api.marketstack.com/v1/eod ? access_key = YOUR_ACCESS_KEY & symbols = AAPL   // optional parameters: & interval = 1h & sort = DESC & date_from = YYYY–MM–DD & date_to = YYYY–MM–DD & limit = 100 & offset = 0 // more parameters available please refer to the API Documentation (https://marketStack.com/documentation) What does the MarketStack API endpoint return? You can use the API’s eod endpoint in order to obtain end-of-day data for one or multiple stock tickers. A single or multiple comma-separated ticker symbols are passed to the API using the symbols parameter. After the call is done main results will be as shown below, […]

Every organization wants to get ahead of security, and security is essential for everyone. Having a secure system always helps you to avoid future problems with your customers.  These current advanced and different technologies that you use give lots of risks to build secure systems. But there are always best practices to prevent dozens of vulnerabilities in your app. Developing a secure app can be a challenge. Customers expect apps to become available and updated faster than ever. In this post, we will try to cover best practices to enhance the security of Windows applications. The better way to protect your source code – preventing people from stealing your ideas and implementation – is to use Delphi. Developing the Best Developer Framework through Benchmarking – This white paper shows really good and real-world metrics of three different frameworks. The white paper includes: Delphi WPF with .NET Electron Overall, it proves that Delphi offers high productivity and better security alongside great functionality. Moreover, when Delphi VCL and FMX demo apps were decompiled, we can see that all the logic code was presented as an assembly which makes it hard to extract source code structure. While when C# WPF and JavaScript Electron demos are decompiled, the source code is easily exposed to a standard text editor. Besides, if you are against reverse engineering of your Windows programs, you can utilize obfuscating tools. Learn more about obfuscating in this tutorials: This shows that with, Delphi programming language with VCL and FMX frameworks, you can achieve high performance and better security over your application. You can learn more about all the comparisons and metrics, be sure to check out these posts: Data-in-flight refers to the connection and the messages transferred across it. For instance, you might need to create a server & client application. In this case, rather than using third-party security protocols, you can rely on platform-specific protocols and layers. RAD Studio offers native and cross-platform Internet Client and Request components to create secure and reliable internet bases programs. The use of Secure Sockets Layer (SSL) and Secure Hypertext Transfer Protocol (HTTPS) ensures the security of the connection. This helps to block intermediary parties from accessing the connections. This kind of authentication is based on a single-user credential which is usually a password. If you are going to build your single-factor authentication you can learn the process here: The user gives a username and password to the identity provider. The provider verifies the identity of the user. The identity provider validates the given username & password. In most cases, the password is encrypted and provides additional security so that others can not read it. Then the identity provides return True or False that indicates authentication status Finally, if it is successful, the system gives access to the user. The problem with Single-factor authentication is that passwords can be easy to guess. This can be solved by adding another layer of the requirement to get into the system. For instance, applying secret questions and regular password changes.  Use an EDP Module. Since we are talking about Windows app development, we are in a better place compared to the web environment. Microsoft Windows 10 and 11 offer Enterprise Data Protection (EDP). The EDP module guards enterprise data against unintended or malicious use and it provides 4 levels of protection: Block, […]

Ethereum is used to create decentralized applications that utilize the benefits of cryptocurrency and blockchain technology. These decentralized applications (dapps) can be trustworthy which means that once they are deployed to the Ethereum network, they will always run as programmed. They can control and regulate digital assets in order to create new kinds of financial applications. They can be decentralized in a way that no single entity or person controls them and are nearly impossible to censor. In this blog post, we’ll look at some of the most popular and effective tutorials that can help you adapt to a quick hands-on for working with Ethereum from Delphi. How can I connect Delphi to a local (in-memory) blockchain? This simple tutorial primarily focuses on connecting Delphi to a local (in-memory) blockchain using Delphereum, which is a Delphi interface to the Ethereum blockchain.  There are a few prerequisites and GitHub repositories/libraries that are required before you actually move on to using Delphereum. After that, you will be required to download and start a Ganache instance to run your personal Ethereum blockchain. Once Ganache is up and running, you can move ahead and start a new Delphi project. For simplicity in understanding, the tutorial uses an easy approach of just connecting to an Ethereum blockchain and retrieve the account balance.  <br /> const<br /> URL = ‘http://127.0.0.1:7545’;<br /> begin<br /> web3.eth.getBalance(TWeb3.Create(URL), Edit1.Text, procedure(qty: BigInteger; err: IError)<br /> begin<br /> TThread.Synchronize(nil, procedure<br /> begin<br /> if Assigned(err) then<br /> MessageDlg(err.Message, TMsgDlgType.mtError, [TMsgDlgBtn.mbOK], 0)<br /> else<br /> ShowMessage(web3.eth.utils.fromWei(qty, web3.eth.utils.ether) + ‘ ether’);<br /> end);<br /> end);<br /> end; const   URL = ‘http://127.0.0.1:7545’; begin   web3.eth.getBalance(TWeb3.Create(URL), Edit1.Text, procedure(qty: BigInteger; err: IError)   begin     TThread.Synchronize(nil, procedure     begin       if Assigned(err) then         MessageDlg(err.Message, TMsgDlgType.mtError, [TMsgDlgBtn.mbOK], 0)       else         ShowMessage(web3.eth.utils.fromWei(qty, web3.eth.utils.ether) + ‘ ether’);     end);   end); end; For a detailed and descriptive understanding, check out the full-length tutorial here.  How can I connect Delphi to the Ethereum main net? The previous tutorial focused on connecting Delphi with local (in-memory) blockchain. In this tutorial, we take a step forward and connect Delphi to Ethereum main net.  To connect to the Ethereum main net, you will need to sign up for a free account on Infura to get a project ID. <br /> const<br /> URL = ‘<your_infura_project_endpoint>’;<br /> begin<br /> web3.eth.getBalance(TWeb3.Create(URL), Edit1.Text, procedure(qty: BigInteger; err: IError)<br /> begin<br /> TThread.Synchronize(nil, procedure<br /> begin<br /> if Assigned(err) then<br /> MessageDlg(err.Message, TMsgDlgType.mtError, [TMsgDlgBtn.mbOK], 0)<br /> else<br /> ShowMessage(web3.eth.utils.fromWei(qty, web3.eth.utils.ether) + ‘ ether’);<br /> end);<br /> end);<br /> end;</your_infura_project_endpoint> const   URL = ‘‘; begin   web3.eth.getBalance(TWeb3.Create(URL), Edit1.Text, procedure(qty: BigInteger; err: IError)   begin     TThread.Synchronize(nil, procedure     begin       if Assigned(err) then         MessageDlg(err.Message, TMsgDlgType.mtError, [TMsgDlgBtn.mbOK], 0)       else         ShowMessage(web3.eth.utils.fromWei(qty, web3.eth.utils.ether) + ‘ ether’);     end);   end); end; Notice that in the code above, we have replaced the local Ganache blockchain URL with the Ethereum main net link that we retrieved from Infura.  For a detailed and descriptive understanding, check out the full-length tutorial here. Can I connect Delphi to smart contracts? In this tutorial, the idea is to explore how can you connect your Delphi applications with the deployed Ethereum smart contracts. The tutorial uses BNB’s smart contract and synchronizes the execution state with the main thread for a seamless connection.  <br /> var<br /> Client: TWeb3;<br /> const<br /> URL = ‘https://mainnet.infura.io/v3/your-project-id’;<br /> begin<br /> Client := TWeb3.Create(URL);<br /> web3.eth.call(Client, ‘0xB8c77482e45F1F44dE1745F52C74426C631bDD52’, ‘symbol()’, [], procedure(tup: […]

Businesses mostly prefer artificial intelligence solutions that are customized as per their needs and serve exactly the same purpose that they want to achieve. In such situations, that require a significant level of customization, desktop apps are still an ideal choice of adoption for fast-paced businesses.  Desktop apps are powerful execution tools that can natively run on your local machine to provide holistic application navigation and utilization experiences. With the advancement of modern web technologies, the desktop application development paradigm also experienced a major drift in terms of implementation. Technologies such as JavaScript and Python have inspired the hybrid implementation of desktop apps. We already know from the Delphi vs. WPF vs. Electron for Windows Desktops Whitepaper that products such as RAD Studio (Delphi and C++ Builder) provide a seamless desktop application utilization experience by enabling native code that is fast, high performant, and memory efficient. Using the potential of REST APIs, you can easily integrate artificial intelligence into your already built desktop apps with Delphi and C++.  In this blog post, we’ll look at how we can use REST APIs to create tremendous Delphi and C++ desktop apps that provide customized artificial intelligence solutions for our own use case.  What are the benefits of using REST APIs for AI? The primary motivation behind designing AI solutions is to study data and predict meaningful insights out of the data. In today’s world, where businesses are producing loads and loads of data, AI serves its best purpose by providing various kinds of predictive outcomes for the companies.  The fact of the matter is, everyone wants to use AI for the larger betterment and benefit, but not everyone has the capacity and capability to design the artificial intelligence solutions in-house by themselves. Be it infrastructural constraints, hardware limitations, lack of human resources, or tight organizational budget, if you cannot afford to set it up then it does not at all mean that you cannot even consume it. The REST APIs and the concept of AI as a service are the changemakers in this entire intelligent automation lifecycle.  The people and ventures who have the required resources provide AI using the REST service. To you, as the end-consumer of their AI resource, it does not matter how they handle the internal complications and functionalities to process machine learning models. You only provide your data points to the third-party service and ask it to do the hard work on your behalf and just return the final output for you to use further. All the hardware, infrastructural, and optimization stuff is efficiently handled by the API service internally.  How does RAD Studio help in creating stunning high-performance AI desktop apps? Now that we know how REST APIs make it really easy to use the power of artificial intelligence, here comes the point where we choose RAD Studio to create impressive desktop apps that make intelligent decisions for their users. Due to Delphi and C++ Builder in RAD Studio, the developed desktop apps have high performance, decreased memory usage, and an overall optimized application utilization experience.  Since RAD Studio provides Delphi runtime and C++ builder, it is tremendously difficult to design and develop AI components with this technology stack and ecosystem. Apart from that, there is no need to recreate the wheel and write ML scripts from scratch […]

When creating a report, it is important not only to make a nice printable form that will display the data the user needs but also a convenient pre-print dialog, where the user can set the parameters to generate the report. The FastReport preprint dialog already contains a number of components, for example, Label, Edit, Button, Memo. But sometimes this is not enough and you have to create your own dialog components for FastReport. In fact, they are analogs of usual Delphi components that can be used in FastReport dialog forms. This article will talk about creating this component. For more information, we recommend reading the FastScript documentation and the FastReport VCL manuals for developers and software specialists. To display data from the database, this article uses the DBGridEh component from the EhLib VCL library L, which will be integrated into the FastReport dialog. Delphi 10.4.2 was used as a development environment, but everything described below will be suitable for any other Delphi starting from version 7 (adjusted for the version). Let’s create a new package (dpk) and name it frxDBGridEh27. Add to it a new file frxDBGridEhControl.pas, which will serve as the basis for our grid. We will declare a component in this file for registration in Delphi: TfrxDBGridEhDialogControl = class(TComponent); TfrxDBGridEhDialogControl = class(TComponent); We begin to describe the TfrxDBGridEh component, which will be created from the base dialog class TfrxDialogControl. In fact, we will re-declare the properties of the base DBGridEh component into a component to use in FastReport. You can re-declare not all properties, methods, event handlers, but only those that are needed for work. In the private section, I recommend paying special attention to the following: private FDBGridEh :TDBGridEh; // The base component, the properties of which we will set and methods of which we will call FDataSource :TDataSource; // Interface between grid and data source in FastReport // Variables that will store the name of the event handlers FOnGetCellParams :TfrxGetCellParamsEvent; FOnGetBtnParams :TfrxGetBtnParamsEvent; FOnTitleBtnClick :TfrxTitleClickEvent; FOnDrawColumnCell :TfrxDrawColumnCellEvent; FOnColEnter :TfrxColEnterEvent; FOnCellClick :TfrxCellClickEvent; FOnColWidthsChanged :TfrxNotifyEvent; // These system procedures are needed to save and restore grid columns to the fr3 report template. procedure ReadData(Reader: TReader); procedure WriteData(Writer: TWriter); // These three methods are needed to be able to connect a basic data source of the TfrxDBDataset (FastReport) or TDataSet (Delphi) type to the grid. function GetDataSet: TDataSet; procedure SetDataSet(const Value: TDataSet); procedure SetDataSetName(const Value: String); // This is the event handler code procedure DoGetCellParams(Sender: TObject; Column: TColumnEh; AFont: TFont; var Background: TColor; State: TGridDrawState); procedure DoTitleBtnClick(Sender: TObject; ACol: Integer; Column: TColumnEh); procedure DoGetBtnParams(Sender: TObject; Column: TColumnEh; AFont: TFont; var Background: TColor; var SortMarker: TSortMarkerEh; IsDown: Boolean); procedure DoDrawColumnCell(Sender: TObject; const Rect: TRect; DataCol: Integer; Column: TColumnEh; State: TGridDrawState); procedure DoColEnter(Sender: TObject); procedure DoCellClick(Column: TColumnEh); procedure DoColWidthsChanged(Sender: TObject); 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 private   FDBGridEh      :TDBGridEh;   // The base component, the properties of which we will set and methods of which we will call   FDataSource    :TDataSource; // Interface between grid and data source in FastReport     // Variables that will store the name of the event handlers   FOnGetCellParams    :TfrxGetCellParamsEvent;   FOnGetBtnParams     :TfrxGetBtnParamsEvent;   FOnTitleBtnClick    :TfrxTitleClickEvent;   FOnDrawColumnCell   :TfrxDrawColumnCellEvent;   FOnColEnter         :TfrxColEnterEvent;   FOnCellClick        :TfrxCellClickEvent;   FOnColWidthsChanged :TfrxNotifyEvent;     // These system procedures are needed to save […]

The first class formed by Tech4Me’s Galileo Project also ended their journey with knowledge in Delphi. What is Project Galileo? The Galileo Project is a Tech4Me initiative that aims to transform the lives of young people from simpler backgrounds through technological education. The proposal is that in 6 months these young people can have the necessary knowledge to enter the job market in a position of junior programmers. Participation of Embarcadero and its Academic Program The first class formed by the Galileo Project had 36 hours of additional content focused on the Delphi language with RAD Studio 10.4.2 Sydney . It took 6 weeks, with 2 weekly meetings per week using the Embarcadero tool in its latest version. This is thanks to Embarcadero’s Academic Program that provided full licensing for students who were able to enjoy all the features of RAD Studio Enterprise. Idea embraced by the Delphi Community The instructors of the Delphi module taught to this first group of graduates of the Galileo Project were already well-known and renowned members, with great performance in the Delphi community. Fernando Rizzato, Kelver Merlotti, Landerson Gomes and Marcos Moreira joined the presented Project and participated donating their time and teaching the content to the students. Employability on the rise As the market has a great demand for IT professionals, the proposal becomes even more convincing when, even before the course is concluded, students begin to be recruited. And so it was. The Alterdata Software , whose president Ladmir Carvalho is also a founding partner of Tech4Me, recruited some young people and they are already working in the company, which is located in the city of Teresopolis – RJ. Ladmir Carvalho and young people recruited from the Galileo Project Thanks I would like to take this post to thank the Tech4Me Team for their support. Cristian, Carol, Bruna …thanks so much for all your support. Ladmir thank you for the memory and for the invitation. Thank you Fernando, Kelver and Marcos for embracing this idea, Embarcadero for the freedom it gave us to participate and contribute something so rewarding. And also a special thanks to these stars located by Galileo, who from now on are new colleagues in the IT field. The original post in Portuguese is available on my website through the link: https://www.landersongomes.com.br/embarcadero/delphi/delphi-no-projeto-galileo. Until the next opportunity.

The Windows Subsystem for Linux allows developers to run a GNU/Linux environment including command-line tools, most of the utilities, and applications directly on their Windows computers. It has become extremely popular and RAD Studio Delphi is able to create Linux applications which run directly on both WSL and full Linux computers. Several WSL distributions are available via the Microsoft Store (Ubuntu, Kali, Fedora, Debian, OpenSUSE) WSL is currently focused for the command-line use but with extensions and programs you can install GUI and connect through remote desktop control utilities. Windows 11 allows Windows users to run full GUI Linux apps via WSL2 which is an updated version of the original WSL. RAD Studio also works with WSL2 and using FMX Linux you can create FULL GUI applications for Linux. WSL is faster and more lightweight on computer resources than a virtual machine. You can execute Linux binaries from Windows and Windows executables from Linux In the recent WSL2 updates, we can see there is a huge increase in file system performance and full system call compatibility for a better experience. You can find how to install WSL on Windows in this official documentation. How can I manage WSL (Windows Subsystem for Linux) with a graphical application? WSL GUI Tool – is an open-source tool built with Object Pascal, Delphi, that manages installed Linux distributions easily with a user interface. The WSL GUI Tool allows you to manage WSL features with GUI & offers these functions: Start & Stop a distribution. Rename distribution. Change flag of distribution from the original WSL version to the new improved WSL2. Edit environment variables. Moreover, you can explore the source code and learn about how to do these all stuff with Delphi which is great! Where can I download the WSL GUI tool? If you would like to just try out the portable executable select the Release section in GitHub and download it. Where can I learn more about using RAD Studio Delphi with Window’s WSL and Linux? The best place is the Windows 10 Modernize Webinar Series. You can learn how to target Windows 10’s Windows Subsystem for Linux with RAD Studio Delphi in this great video from Jim McKeeth: Where can I download the Delphi Object Pascal source code for the WSL GUI Tool? You can go to the following link for the official WSL GUI tool here: https://github.com/emeric-martineau/wsl-gui-tool Why not download a free trial of RAD Studio today and try the code out for yourself?