5-Minute Snack: Getting to know FmxLinux…and being amazed!

With Tokyo out of the door and finally having the means again to write server-side code for a Linux system, I will still a bit disappointed not being able to design user-interfaces with Delphi and deploy them to Linux.

Yes, Embarcadero made it crystal clear what their approach towards Linux will be, but I think as we are all enthusiastic about Delphi, we were hoping for some sort of FireMonkey support as well. I still remember setting up KDE for Kylix back in the days…

A couple of days ago my Facebook feed caught a news item about “FmxLinux”. Furthermore, the term got shared over and over again on LinkedIn and thus it triggered my interest. I found out that FmxLinux would extend FireMonkey so that it would support the Linux platform with a Linux system that is running a graphical user environment.

Having already set up a Virtual Machine with Linux for my Delphi server projects, I decided to set up another Desktop-based Linux virtual machine in order to give it a test run.

As Tokyo supports Ubuntu, I chose “Ubuntu Desktop 16.04.2 LTS”:

After downloading the ISO you can follow the steps written by Pawel Glowacki precisely, found here

I suggest selecting “Auto Login” during install, so that the Desktop is loaded right away without the need to log in. Furthermore, you will need to open “Terminal” in order to type in the commands that Pawel describes in his blog post. Still, they are precisely the same for the Desktop version.

After installing the PAServer, you can start it just the same as on the server version of Ubuntu:

You can see that I used FmxLinux already.

Now to the giant task to install FmxLinux. I expected a lot of work as it is a download of a beta version. Also, my hopes were not up that it would work right out of the box.

I was very wrong!

With a simple click to “Download Free Trial v 0.92” I downloaded an exe file that will install everything into your Delphi environment.

Took me less than a minute.

I started Delphi and created a FireMonkey application. I did not use a template and dropped a TListBox (Info) and a TStatusBar with an embedded TLabel.

I double-clicked the form and entered the following code snippet, adding System.IOUtils  to the uses-clause as well:

I also added an implementation for the MouseMove-event of the form:

Running the app yields the expected result as 64-bit Windows has been selected by default:

If you want to select Linux as the target platform you will be disappointed. It is impossible. However, with FmxLinux installed you may right-click the Project File in the Project Manager and you will find a context-menu item called “Add Linux platform”. If you already added it before and made changes to your configuration you can even update the platform config using this approach without editing any configuration files manually. FmxLinux offers an “Update Linux platform” action for that.

Again, not expecting much, I double-clicked the Linux platform entry and ran the app.

Wow! It works out of the box, no configuration hassle, nothing. 

And investigating the results that are added to the TListBox, even the system-specific aspects work nicely. I point this out because a server system might not have the need for a download directory e.g. The directories I picked are pretty “user-specific”.

Summed up, for a very early Trial version the results are simply amazing.

The maturity of the user-experience is very high. It takes absolutely no effort “what-so-ever” to deploy your application to a Linux Desktop. Once deployed you can run it without the “PAServer” like any other binary on the system.

Next I will try to write a REST Client with data grids and see what the user experience is going to be like. Furthermore, I might try using some FireDAC components..

Kudos to Eugene Kryukov for creating a wonderful product that will open up Delphi to a whole new world of development possibilities.

Posted in Delphi Tagged with: , , , ,

Free Video Series: Mapping with Delphi and TMS WebGMaps

I recently finished a 3-part video series about TMS WebGMaps, a wonderful mapping component for VCL and FireMonkey that completely abstracts from the Google Maps API. You can fully concentrate on creating your Delphi application without bothering about the pitfalls of the REST API. 

Have a look at the series to learn about many other advantages using that component set.

We even created two language versions: English and German. As an aside, each video has different pictures as well as audio. Demo source code and slides are available from the TMS Website.

The video parts have the following major topics:

  1. Introduction
  2. Geocoding and Reverse Geocoding
  3. Directions and Routing

 


Ich habe kürzlich eine 3-teilige Videoserie über TMS WebGMaps erstellt, eine wunderbare Mapping Komponente für VCL und FireMonkey. Von der Google Maps API wird komplett abstrahiert. Man kann sich komplett auf das Programmieren der eigentlichen Funktionalität konzentrieren und muss sich nicht mit den Besonderheiten der REST API auseinandersetzen.

Weitere Vorteile durch die Nutzung der Komponente werden in der Videoserie ausführlich erläutert.

Wir haben sogar zwei Sprachfassungen erstellt: Englisch und Deutsch. Ganz nebenbei hat jedes Video eigenes Bild und Ton. Der Quelltext der Demos und die Folien sind ebenfalls verfügbar auf der Webseite von TMS.

Die Serie wurde in die folgenden Hauptteile unterteilt:

  1. Einleitung
  2. Geocoding and Reverse Geocoding
  3. Directions and Routing

Part 1, English 

Part 1, German

Part 2, English

Part 2, German

Download for Source Code: http://www.tmssoftware.net/public/WebGMapsDemosGeocoding.zip

Part 3, English

Part 3, German

Posted in Delphi Tagged with: , ,

5-Minuten-Snack: Einführung ins Styling der VCL

Es handelt sich um die deutsche Übersetzung eines Artikels (Link). Die Übersetzung erfolgte durch den Autor und nicht maschinell.

Ich habe mich mit einer Funktion der VCL bisher gar nicht beschäftigt: Styling. Ich erstelle in der Regel keine Anwendungungen für einen Industriezweig in dem das grafische Design einer Anwendung eine bedeutende Beachtung finden würde – der Fokus liegt meist auf der einfachen, intiutiven Nutzung.

Das bedeutet meistens: große Schaltflächen und die wichtigsten Informationen zu jedem Zeitpunkt darstellen. Insbesondere der letzte Teil bereitet häufig Kopfschmerzen. Denn — sind wir mal ehrlich — in dem Moment wo wir als Entwickler einen bestimmten Wert ‘immer’ anzeigen, dann möchte der Kunde genau den Wert auch ‘immer’ ändern können…

Ganz nebenbei… es mag länger dauern diesen Artikel zu lesen als 5 Minuten. Allerdings hat der 5-Minuten-Snack sich als ein fester Bestandteil meines Blogs in der Delphi Community etabliert, so dass ich nicht in Abhängigkeit von der Lesedauer die Zahl ändern werde…

Weiterhin handelt es sich beim Styling um die Funktionalität, die an mir vorbei ging ohne, dass ich darauf aufmerksam wurde. Ich habe diese Dinge immer mit FireMonkey in Verbindung gebracht, nicht aber mit der VCL. Insbesondere, das es im Bereich der Drittkomponenten zahlreiche Lösungen dieser Art bereits gibt. Eine dieser Lösungen ist z.B. die TMS Skin Factory (Link).

Trotzdem wurde ich darauf aufmerksam während ich einen Workshop zur Komponentenentwicklung mit Delphi im Mai vorbereitete (Link). Es ist offensichtlich, dass neue Komponenten für die VCL diese Funktionalität unterstützen sollten.

Somit begann ich damit, eine ganz einfache Anwendung zu bauen, die es mir gestattet die verschiedenen Stile eines Formulars durchzublättern und ich dann direkt eine visuelle Einschätzung des jeweiligen Stils habe.  Ich werde diese Demo hier veröffentlichen, damit auch euer Interesse an den Styles geweckt wird und ihr schnellstmöglich loslegen könnt. Vielleicht handelt es sich um einen Bereich, der auch euch noch nicht vertraut ist.

(Ab jetzt werde ich auch einheitlich von “Styles” sprechen und nicht mehr die deutsche Übersetzung verwenden….)

Genug der Vorrede, wir erstellen eine VCL Formularanwendung und fügen dem Formular die folgenden Komponenten hinzu. Die Anordnung sollte in Anlehnung an den Screenshot erfolgen. Anchor können benutzt werden; ich habe darauf verzichtet. Daher habe ich direkt den FormStyle auf einen Typ mit konstanter Fenstergröße geändert.

  • TComboBox : ‘cbStyles’ zu nennen – die einzige Komponente, die einen bestimmten Namen erhalten muss.
  • TEdit 
  • TButton 
  • TRadioGroup  mit einigen Einträgen
  • TGroupBox  mit zwei  TCheckBox 
  • TPageControl  mit einigen Registern ( TTabSheet)

Um auch zu testen, ob Komponenten von Drittparteien das Styling implementieren können, habe ich noch ein TAdvStringGrid  von TMS Software hinzugefügt.

Mein Demo sieht im Formdesigner wie folgt aus:

02

Um VCL Styling nutzen zu können, müssen wir die folgende Unit zur uses-Klausel hinzufügen:

Auch mal etwas Kritisches von meiner Seite: Ich habe keine Ahnungm, warum es keine ordentliche, einheitliche Benennung der Terminologie gibt. Die gesamte IDE verwendet den Terminus ‘style’ und weiterhin ‘custom styles’ (angepasste Stile), aber die Unit benutzt ‘theme’. Sicherlich wurde das bei der Entwicklung übersehen, was sicherlich oftmals zu Verwirrungen führen dürfte. Ich kenne es nur, dass Styles Bestandteil eines Skins oder eines Themes sind. Im Bezug auf die VCL ist es also so, dass die Begriffe Style und Theme synonym verwendet werden.

Wenn wir die Unit unter die Lupe nehmen, finden wir direkt sehr nützliche Informationen zu Beginn der Datei:

Jetzt wissen wir, welche grafischen Komponenten das Styling unterstützen.

Gerne könnt ihr weitere grafische Komponenten auf eurer Formular des Demos aufnehmen, um zu schauen, wie sie von einem Style beeinflusst werden. Mein Formular enthält nur einige ausgewählte. Die einzige Komponente, auf die es ankommt, ist die ComboBox. Sie wird alle verfügbaren Styles auflisten und die Auswahl ermöglichen.

Weiterhin definiert die Unit auch noch eine Kernklasse des Stylings:  TStyleManager.

Wir können sie benutzen, um eine Liste aller für die Anwendung verfügbaren Styles abzufragen. Zudem können wir den gewünschten Stil für die Anwendung bestimmen.

Müssen wir eine Instanz von  TStyleManager ableiten? Nein. Alle Methoden sind als Klassenmethoden definiert.

Somit können wir den nachfolgenden Code im FormCreate -Ereignis verwenden, um die ComboBox mit den Namen der verfügbaren Styles zu befüllen:

Es ist anzumerken, dass wir die verschiedenen Namen der Styles per for-in-Schleife sehr komfortabel iterieren können. Zudem setzen wir den aktuellen Eintrag der ComboBox auf den Namen des zur Zeit aktiven Styles der Anwendung. Diese Information können wir ebenfalls über  TStyleManager abfragen.

Die ComboBox wird nun mit allen Namen befüllt werden. Zumindest gehen wir davon aus… Leider ist das nicht der Fall. Es wird nur ein Style gelistet mit dem Namen ‘Windows’.

def01

Delphi erwartet, dass wir noch eine Sache mehr erledigen. Wir müssen der IDE mitteilen, welche Styles in unsere Anwendung einzubinden sind. Daher, wenn wir uns die Projektooptionen (Projekt/Optionen…) im Abschnitt “Anwendung/Aussehen” anschauen, können wir direkt erkennen, dass kein Style ausgewählt wurde:

def02

Jetzt sind wir ein wenig verrückt und wählen alle aus! 🙂

01

Den Standard (d.h. zum Start der Anwendung) setze ich auf ‘Windows 10’.

stwindows10

Und… die Anwendung ist gestyled. Wir sehen nun auch die Liste aller markierten Styles in der ComboBox. Trotzdem können wir weiterhin den aktuellen Style nicht verändern. Das werden wir durch Implementierung eines Ereignisses bei Änderung der Auswahl der ComboBox erledigen ( OnChange -Ereignis):

Wir können die Methode SetStyle von TStyleManager verwenden, indem wir den Namen des zu verwendenden Styles übergeben. Es handelt sich tatsächlich nur um einen String, d.h. jeder Style ist eindeutig durch einen String bestimmt, der z.B. auch sehr einfach in den Anwendungseinstellungen abgelegt werden kann.

Nun verändert das Formular direkt sein Aussehen, wenn wir die Auswahl in der ComboBox ändern:

stlavender

Der Screenshot oben zeigt den Style namens ‘Lavender Classico’. 

Es ist anzumerken, dass auch die Komponente der Drittpartei wunderbar gestyled wird.

Um ehrlich zu sein war ich sehr überrascht, wie viel einfacher als erwartet die Verwendung von Styles mit TStyleManager  ist. Die IDE ermöglicht komfortabel die Auswahl der bereitzustellenden Styles. Bestehende Anwendungen, die hauptsächlich Standardkomponenten verwenden oder mit Drittparteikomponeten, die die neue Technologie unterstützen, können mit nur wenigen Zeilen Code migriert werden. Die Anwendungseinstellungen mit dem ausgewählten Style zu erweitern ist ebenfalls sehr einfach, da es sich nur um einen einzigen String handelt, der gespeichert werden muss.

Posted in Delphi Tagged with: , , , ,

Delphi 10.2 Tokyo Beta: Daten in einem TFDMemTable zur Laufzeit bearbeiten

Es handelt sich um eine Übersetzung durch den Autor des englischen Posts (Link) und keine maschinelle Übersetzung.

database-155892_640Ich habe heute die Erlaubnis erhalten über die Beta von Delphi 10.2 Tokyo zu bloggen.

Sicherlich habt ihr bereits viele Dinge zur Unterstützung von Linux und anderen Verbesserungen im Rahmen des Compilers gelesen. Als ein Entwickler von zahlreichen Datenbankanwendungen, finde ich die folgende Neuerung großartig:

 

 

FDMemTable  unterstützt nun das Editieren von Tabellen zur Entwicklungszeit. Die Daten werden zusammen mit dem Formular gespeichert und sind auch zur Laufzeit verfügbar.

Das eröffnet uns einige neue Möglichkeiten mit FDMemTable . In diesem Beispiel werde ich zeigen, wie man eine Tabelle mit Feldern definiert und dann zur Entwicklungszeit bereits mit Werten füllt. Natürlich könnten wir auch direkt XML oder eine binäre Datei laden. Weiterhin ist es sogar möglich bereits zur Entwicklungszeit Daten aus einer FDQuery  in den FDMemTable  einzufügen, um so auf eine gewisse Menge an Vorgabewerten zugreifen zu können, wenn noch keine Datenbankverbindung etabliert wurde. Dazu ist FDMemTable  in der Lage seine Daten auch für andere Komponenten für verschiedenste Szenarien während der Entwicklung bereitzustellen. FDMemTable  ist wesentlich flexibler und komplex als TFDTable . TFDMemTable  ist wohl eher mit der Komponente TClientDataset  gleichzusetzen.

Um die Funktionalität zu zeigen, habe ich die folgenden Schritte durchgeführt:

  1. Eine neue “VCL Forms Application” (VCL Formularanwendung) erstellt
  2. Einen TFDMemTable  auf das Formular gezogen.
  3. Das Kontextmenü von TFDMemTable  mit Rechtsklick geöffnet.

Jetzt kann man die neue Funktionalität erkennen. Jedoch können wir noch keine Daten erfassen, da wir keine Felddefinition festgelegt haben.

fd01

Aus diesem Grund öffnen wir zunächst den Feldeditor und fügen neue Felder hinzu. Zum Beispiel: Name, Street, City, Zip und State:

fd02

Da es keine Änderungen in Tokyo bei der Erstellung von Feldern  gibt, habe ich keinen Screenshot erstellt.

Abschließend nutzen wir die neue Funktion, indem wir auf  “Edit DataSet …” klicken:

fd03

Das Fenster zeigt einen Datenbanknavigator und ein Datengrid. Beide Komponenten erlauben es uns, Daten sehr einfach einzugeben, zu bearbeiten und zu löschen. Es gibt sogar eine “Clear” Schaltfläche, um alle Daten zu löschen. Die Schaltfläche mag überflüssig erscheinen, aber da man sehr große Datenmengen aus einer Datei laden kann, kann man gleichermaßen auf diesem Weg alle Daten ruckzuck löschen. Um Daten zu laden oder zu speichern müssen wir das Kontextmenü benutzen. Die Funktionalität ist in dem neuen Fenster nicht zu finden.

 

Mit Delphi 10.2 Tokyo können wir somit Daten für unsere TFDMemTables  bereits zum Zeitpunkt der Entwicklung bereitstellen. Die neue Funktionalität verbessert nicht nur die Gestaltungsmöglichkeiten während der Entwicklung, sondern gestattet es uns auch Daten für die Laufzeit bereitzustellen und vorzubvereiten.

 

Posted in Delphi Tagged with: , , , ,