XProfan-Buch

Deutsch

prfBook

Nur Rohdaten - Kommentare werden in {} angezeigt!

==== [1. Vorbemerkungen] ====
=== [1.1. Über die Windows-Programmiersprache Profan² bzw. XProfan] ===
Über XProfan

XProfan (PROgrammieren Für ANwender) von Roland G. Hülsmann (RGH) ist eine moderne Programmiersprache, welche dem Anfänger den Einstiegin die Windowsprogrammierung insofern erleichtert, als er sich zunächst nicht die Grundlagen der objektorientierten Programmierung aneignen muss.

In nunmehr über zwanzigjähriger Entwicklungszeit wurde XProfan nicht nur von Hobbyprogrammierern schätzen gelernt, sondern auch professionelle Programmierer arbeiten in zunehmendem Maße mit dieser Programmiersprache, um die Entwicklungszeit ihrer Programme abkürzen zu können. XProfan bietet dem Programmierer alle Multimedia-Fähigkeiten von Windows: Ob Grafiken oder Animationen anzeigen, ob Sounds oder Videos abspielen - in XProfan funktioniert dies (fast) wie von selbst.

Vieles geht oft schon mit einem Befehl oder mit einer Funktion. Wo andere Programmiersprachen riesige Bibliotheken benötigen, kommt XProfan mit sich selber aus. Der fortgeschrittenere XProfan-Programmierer kann selbstverständlich sowohl über die Funktionalitäten der Windows- API verfügen, als auch externe Funktionsbibliotheken (DLLs) in seinen Programmen verwenden und so den Funktionsumfang von XProfan nahezu beliebig erweitern.

XProfan 10.0a ist als Vollversion auf der Homepage des Autors [...]

erhältlich.

Ab der Version 8 wurde aus Profan² (*) XProfan. Das „X“ in „XProfan“ steht hier für „extended“ = „erweitert“. Die wesentliche Erweiterung ab XProfan 8 war die Möglichkeit, nun auch in Profan² bzw. XProfan objektorientiert programmieren zu können.
Obwohl XProfan die Möglichkeit des objektorientierten Programmierens bietet, so wird niemand dazu gezwungen, objektorientiert programmieren zu müssen, denn auch XProfan unterstützt nach wie vor das traditionelle prozedurale Programmieren.

Vielfältige Programmiertools, Funktionsbibliotheken und Beispiel-Quellcodes zu XProfan sind überwiegend kostenlos im Internet erhältlich. Darüber hinaus gibt es eine bundesweite Plattform zum Gedanken- und Meinungsaustausch für interessierte XProfan-Programmierer im Internet unter [...]

mit Forenbereichen, Dokumentationen zur Programmiersprache und Hilfestellungen - nicht nur für Programmieranfänger.

Ich möchte hier keinesfalls behaupten, XProfan müsse man nicht erlernen!
Doch wer in seiner Schulzeit etwas aufgepasst hat und mit dem logischen Denken nicht allzu sehr auf Kriegsfuß steht, der wird sich recht schnell in die relativ einfache Syntax von XProfan hineinfinden können.
So wunderbar einfach XProfan auch gehalten ist - wer jedoch glaubt, mit dem Erhalt einer XProfan- Vollversion bereits Windows-Programmierer zu sein, dem sollte mit auf dem Weg gegeben sein:
Wie mit jeder anderen Windows-Programmiersprache - so ist es auch mit XProfan: Nur durch viel Fleiß werden Sie eines Tages diese Programmiersprache beherrschen.

Doch bis dahin werden Sie wahrscheinlich noch des öfteren einen „Dolmetscher“, z.B. dieses (sich in der Entwicklung befindliche) XProfan-Lehrbuch, oder aber auch jederzeit im Internet stets hilfreich zu bekommende Antworten auf Ihre xprofanen Anfragen in der XProfan-Community (https://xprofan.com) bzw. im offiziellen XProfan-Support-Forum (https://xprofan.de) benötigen.

Dietmar Horn †

(*) Was bedeutet(e) das „²“ in Profan²? In einer sehr frühen Version seines Profan, die der Autor damals (um 1992 herum) vorerst nur an gute Bekannte und Freunde zum Testen verteilt hatte, gingen dem Autor durch einen Festplatten-Crash wesentliche Teile des Quellcodes von Profan unwiederbringlich verloren. Daraufhin begann er aus dem Gedächtnis mit dem Neuschreiben von Profan. Profan 2.0 wäre für diese „zweite“ Version von Profan nicht angebracht gewesen, weil es ja noch keine veröffentlichte Version 1.0 gegeben hatte. Also entschied sich RGH kurzerhand dafür, sein „Kind“ ab sofort vorerst Profan² zu nennen (bis Profan² 7.6) .

== [Anmerkungen des Autors von XProfan, Roland G.Hülsmann:] ==
„In den ersten Profan-Versionen gab es GOTO und GOSUB, und diese funktionierten natürlich mit Sprungzielen die nach der aktuellen Zeile folgten. Würde der Interpreter (oder Kompiler) bei einem GOTO oder GOSUB erst den Code von der Platte einlesen müssen, bis er das entsprechende Label findet, würde das Ganze unerträglich langsam werden. Und selbst für Sprünge zurück müsste er dann wiederum die Zeilen aus der Datei lesen. Das wäre schlicht nicht praktikabel.

Also lesen Interpreter und Kompiler den kompletten Code ein, um ihn dann abzuarbeiten. Die ersten Profan-Versionen wurden mit TurboPascal für Windows 1.0 und später Delphi 1 erzeugt. Unter 16 Bit war die Größe einer Datenstruktur auf 64kB (=2^16 Byte) beschränkt. Man konnte auf Speicher also nur in 64kB-Portionen (genannt Segmente) zugreifen. Um das Programm im Speicher zu halten, wählte ich also ein Array aus 16348 Zeigern (ein Zeiger benötigte auch damals schon 4 Byte: 2 für das Speichersegment und 2 für die Adresse in diesem) auf Strings, die damals maximal 255 Zeichen.lang sein konnten. Dynamische Arrays gab es in Delphi noch nicht. Die 16-Bit-Versionen von Profan konnten also maximal mit 16384 Zeilen zu je 255 Zeichen umgehen, was rein rechnerisch immerhin schon 4 MB große Programme ermöglichte.
(Gewiß wäre schon damals unter entsprechendem Aufwand eine dynamische Speicherverwaltung möglich gewesen, aber das wäre zum Einen auch recht langsam gewesen und zum anderen wollte ich mir diesen Aufwand nicht antun.)

Dann kamen Windows NT 3.5 und Windows 95 und damit die 32-Bit-Welt mit linear adressierbaren Speicher und dazu passende Delphi 2. Hier wurde jetzt die Begrenzung der Zeilenzahl durch meine Profan-Architektur, bzw. das Format des Compilates vorgegeben: Für kompilierte Zeilennummern (Sprungadressen innerhalb des Codes) benutzte ich einen 2-Byte-Wert. Daher erhöhte sich zunächst die theoretische Grenze auf 65535 Zeilen.

Nachdem ein gewisser Programmierer* sich nicht mehr auf 64k Zeilen disziplinieren konnte, schrieb ich Kompiler und Runtime um, und verwandte für Sprungadressen im Compilat nun ein LongInt mit 4 Byte, wobei wir bei einer theoretischen Zeilenzahl von bis zu 2 Milliarden sind. (Delphi 2 kannte noch keine vorzeichenfreien 4-Byte-Integer.) Da Delphi 2 aber noch keine offenen Arrays (dynamische Arrays, die nicht bei Deklaration in der Größe festgelegt werden müssen) kannte, setzte ich die Zeilenzahl auf die derzeit gültigen 256k Zeilen fest. (Das Array mit 256k Zeigern belegt beim Programmstart immerhin bereits 1 MB Speicher.) So entstand "XProfan 8 XXL", das jener Programmierer* (und nach dessen Test auch die Kunden mit Update-Abo) erhielten). In XProfan 9 wurde diese Erweiterung dann "Allgemeingut".

Inzwischen bin ich über Delphi 5 zu TurboDelphi "aufgestiegen" und Delphi verfügt nun über erstaunlich schnelle offene Arrays. Damit kann ich mein XProfan nun mit vertretbarem Aufwand umstellen. Das hat neben der nun unbegrenzten (im Rahmen des verfügbaren Speichers) Zeilenzahl den Vorteil, dass Programme, die weniger als 256k Zeilen haben, nun weniger Speicher beanspruchen.

Ähnliches wie für die Zeilenzahl gilt auch für die Zahl der Variablen eines Typs. Auch diese wird vermutlich künftig unbegrenzt sein. Bei ersten Tests konnte ich keine signifikante Verlangsamung von XProfan durch die neue Dynamik feststellen, aber eine deutliche Reduzierung des Speicherverbrauchs von Programmen, die die bisherigen Grenzen nicht ausschöpfen. XProfan benötigt derzeit etwa 35 MB, in meiner dynamischen Testversion nur noch 14 MB.**

Gruß Roland [...]

* Gemeint war damit Dietmar Horn, der Autor dieses Lehrbuches.
** Diese Feautures sind ab XProfan 11 verwirklicht.

=== [1.2. Zum Anliegen dieses Lehrbuches] ===
== [1.2.1. Überblick] ==
So wunderbar und einfach XProfan auch gehalten ist – wie bei allen anderen Programmiersprachen ebenfalls, muss natürlich XProfan auch erst einmal erlernt werden.

Dieser Einführungskurs soll dem Programmieranfänger anhand von Beispielen helfen, sich die Grundlagen der strukturierten Programmierung mit XProfan anzueignen. Hierbei werden Grundkenntnisse über das Betriebssystem Windows und seine Bedienung zwingend vorausgesetzt, die jedoch nicht Gegenstand des Kurses sind.

Das Anliegen des Kurses besteht in keiner Weise darin, alle Befehle und Funktionen der Programmiersprache vollständig aufzulisten und nacheinander zu kommentieren, sondern vielmehr für den Anfänger wichtige Schwer- und Orientierungspunkte zu setzen, die es ihm nach und nach ermöglichen, seine Kenntnisse in zunehmendem Maße selbständig mit der XProfan-Hilfe und mittels Anregungen aus dem Internet zu erweitern, nachdem er sich wesentliche Grundlagen der strukturierten Programmierung und des Aufbaus eines XProfan-Programmes angeeignet hat.

Hierzu werden mehrere Beispielprogramme schrittweise entwickelt.

Dieses XProfan-Lehrbuch richtet sich in erster Linie an Anwender der Vollversion XProfan X3 und folgende – jedoch sind viele Inhalte auch auf niedrigere XProfan-Versionen anwendbar (z.B. auf die aktuelle Freeware-Version XProfan Free 10.0).

Es ist ratsam, alle Lektionen dieses Tutorials nacheinander durchzuarbeiten und bei eventuellen Unklarheiten zusätzlich auch die XProfan-Hilfe für ergänzende und weiterführende Hinweise zu Rate zu ziehen.

Antworten auf weiterführende Fragen zum Programmieren mit XProfan findet jeder Programmierer regelmäßig hier in der XProfan-Community.

== [1.2.2. Hinweise zu den Demo-Quellcodes] ==
In diesem Tutorial sind zahlreiche Quellcodes enthalten, die dem Leser das Lernen erleichtern
sollen. Damit diese (besonders bei umfangreicheren Codes) vom Anwender nicht immer erst
mühsam ein- bzw. nachgetippt werden müssen, werden Sie an den Beitrag zum downloaden angehängt.
{Format für die Downloadversion hier noch reinschreiben}

== [1.2.3. Lizenzrechtliches und Copyright] ==
Alle Teile des vorliegenden XProfan-Lehrbuches und der beiliegenden Programme „Lehrbuch-
Helfer“ und „XProfan-Manager“ unterliegen dem Copyright...
{Rechtlich der letzte Vorsitzende des Vereins - David... ???}

=== [1.3. Die Entwicklungsumgebung von XProfan] ===
Nach der Installation der Vollversion von XProfan befinden sich neben zahlreichen Beispielen, Demos und Zusatzprogrammen u.a. folgende Dateien im Installationsordner, welche den eigentlichen Kern der Programmiersprache XProfan bilden:

	XPPROFED.EXE		Standard-Editor zum Schreiben der Quelltexte
	SCILEXER.DLL		Funktionsbibliothek, die vom XProfan-Editor benötigt wird
	PROFAN.EXE		Interpreter zum Ausführen der Quellcodes während der Programmentwicklung
	PRFRUN32.EXE		Runtime-Modul der Programmiersprache
	PROFCOMP.EXE		Kompiler zum Übersetzen des Programmcodes in Maschinensprache
	PROFLINK.EXE*		Linker zum Erstellen der ausführbaren EXE-Datei
	PROFAN.CHM		Hilfedatei zur Programmiersprache im modernen CHM-Format

* Ab XProfan sind Kompiler und Linker in der Datei PROFCOMP.EXE vereinigt. Der Linker liegt eigentlich nur noch aus Kompatibilitätsgründen zu älteren Versionen von XProfan-Editoren bei, weil diese zum Linken des Kompilates zwingend die Datei PROFLINK.EXE voraussetzen. In Wirklichkeit ruft der Linker nur den Kompiler mit einem speziellen Parameter zum Linken auf.

== [1.3.1. Der Editor XProfed] ==

XProfed ist ein Standard-Editor zum Schreiben von XProfan-Quellcodes. Zwar könnte hierfür auch jeder andere Editor Verwendung finden, welcher reinen ANSI-Code erzeugen kann (notfalls sogar das windowseigene NOTEPAD), jedoch bietet XPROFED.EXE vielfältigere Möglichkeiten zur Vereinfachung des Ausführens und Erstellens von XProfan-Programmen.

Eine kontextsensitive Hilfe (Aufruf mit Strg + F1) zeigt die Hilfe zum Schlüsselwort an, auf dem sich der Cursor gerade befindet.

Eine Projektverwaltung erleichtert die Arbeit an verschiedenen Projekten, indem man verschiedene Runtime-Module PRFRUN32.EXE mit unterschiedliche Icons und sonstigen Ressourcen definieren kann.

Die Möglichkeit des „Faltens“ des Quellcodes (in längeren Codes können Unterprogramme – sogenannte Prozeduren) ausgeblendet werden, um die Übersichtlichkeit beim Arbeiten an umfangreicheren Projekten zu erhöhen – und bei Bedarf natürlich wieder eingeblendet werden (jeweils mit der F4-Taste).

Im linken Navigationsfenster werden die genannten Code-Abschnitte übersichtlich aufgelistet, so dass diese per Mausklick bei Bedarf automatisch in den sichtbaren Bereich des Editorfensters gesrollt werden.

Mehr Informationen und neuste Versionen unter [...]

== [1.3.2. Der Interpreter PROFAN.EXE] ==
Der Prozessor eines jeden Computers besitzt einen (relativ begrenzten) Sprach- bzw. Befehlsvorrat, der ihn befähigt, bestimmte Aufgaben (z.B. die Addition zweier Zahlen) auszuführen. Unser XProfan-Programm greift auf diesen Befehlsvorrat zu und erteilt dem Prozessor genauere Anweisungen, was er zu tun hat.

Weil die „Muttersprache“ des Prozessors (die „Maschinensprache“) nur aus lauter Nullen (0) und Einsen (1) besteht, ist diese vom Menschen nicht gerade leicht zu erlernen. Denn für den Computer würde etwa die Anweisung „Addiere die Zahlen 1 und 4!“ so aussehen:

00101110

00000001

00000100

Abhilfe schafft hier die Einführung einer Art „Dolmetscher“, der dem Computer den relativ leicht zu erlernenden „menschlichen“ Befehl „Addiere 1 und 4“ in die verständliche Form seiner „Computersprache“ (in das sogenannten Dualsystem, welches auf die beiden Ziffern 0 und 1 aufbaut) übersetzt.

Dieser Übersetzungsvorgang kann vor der eigentlichen Programmausführung (auf dem PC des Programmierers) geschehen und wird als „Kompilieren“ (engl. compilieren) bezeichnet. Das Programm, welches diese Arbeit erledigt, heißt „Kompiler“.

Im Gegensatz dazu könnte das Programm natürlich auch erst während der Programmausführung in die dem Computer verständliche Maschinensprache übersetzt werden. In diesem Fall spricht man von einem „Interpreter“. Die Ausführung im Interpretermodus beansprucht Rechnerleistung und somit Zeit, weil der Interpreter vom Programmcode immer nur die Zeile zu Gesicht bekommt, die er gerade abarbeitet, während der Kompiler während der Übersetzung in die Maschinensprache bereits das gesamte Werk kennenlernte und dieses danach bis zum Faktor 10 (oft auch darüber) schneller ausführen kann.

Der Interpreter PROFAN.EXE wird verwendet, um das Programm während des Erstellens auszuführen und zu testen (Aufruf im XProfan-Editor über die F7-Taste).

Hierzu öffnet der Interpreter die Quellcode-Datei (z.B. Hallo World.prf) und führt sie Zeile für Zeile aus. Bei einem Fehler im Programm bricht der Interpreter die Ausführung in der entsprechenden Zeile ab, anderenfalls führt er das Programm aus.

== [1.3.3. Das Runtime-Modul PRFRUN32.EXE] ==
Das Runtime-Modul von XProfan beinhaltet sämtliche Befehle und Funktionalitäten der Programmiersprache. Sollen Ressourcen (z.B. Icons) ausgetauscht oder hinzugefügt werden, so ist das Runtime-Modul zu bearbeiten und nicht die fertige EXE-Datei. Wenn die Veränderungen auch im Interpretermodus wirksam werden sollen, ist zusätzlich die Datei PROFAN.EXE anzupassen.

Ab der Version X3 gibt es die Möglichkeit, Ressourcen mit $RES auch direkt beim Linken in sein Programm einzubinden.

== [1.3.4. Der Kompiler PROFCOMP.EXE] ==
Der Kompiler PROFCOMP.EXE wandelt den Quellcode (z.B. TEST1.PRF) in Maschinencode um, der wesentlich schneller ausgeführt wird, als der Quellcode im Interpretermodus. Das Ergebnis des Kompilierens ist eine Datei mit der Endung PRC, also z.B. TEST1.PRC. Zum Ausführen des Maschinencodes wird das Runtimemodul mit der PRC-Datei als Parameter aufgerufen. Im XProfan-Editor erfolgt das Kompilieren durch Betätigen der F9-Taste, das Ausführen des Kompilates mit der Taste F8.

== [1.3.5. Die Hilfedateien PROFAN.CHM] ==
Die Hilfeseite zu einem XProfan-Befehl kann vom XProfan-Editor aus aufgerufen werden, indem Sie den Cursor in das Schlüsselwort setzen, zu dem Sie Hilfe benötigen, und danach die Tastenkombination Strg + F1 drücken.

Im Inhaltsverzeichnis der Hilfedatei finden Sie u.a. eine kurze Einführung zur Programmiersprache, sowie eine Übersicht zum Befehlsumfang von XProfan, einschließlich ausführlicher Erläuterungen zu speziellen Themen rund um das Programmieren mit XProfan.

{Zusatzprogramme, Helfer etc... in einem Anhang zum Buch schreiben}

12.12.2015 ▲

Vollständiges Zitat

Absatzweise zitieren Zeilenweise zitieren

prfBook

==== [2. Erste Schritte zum ersten Programm] ====
Starten Sie den XProfan-Editor und erzeugen Sie über „Datei“ - „Neue Datei“ - eine leere Quelltext-Datei.

Speichern Sie diese in Ihrem XProfan-Ordner unter einem selbst gewählten Dateinamen ab („Datei“ - „Speichern“) - z.B. „Kurs001“. Die Endung „.prf“ müssen Sie nicht eintippen, denn diese wird ggf. vom Editor automatisch vergeben. Oben links im ersten „Reiter“ müsste nun stehen: „Kurs001.prf“

=== [2.1. Einige Grundregeln für das Schreiben von XProfan-Quelltexten] ===
Für das Erstellen von XProfan-Quellcode-Dateien gilt:

Jede Quellcode-Datei wird zeilenweise von oben nach unten geschrieben (und später auch von oben nach unten vom Interpreter zeilenweise ausgeführt bzw. vom Kompiler in Maschinencode übersetzt).

In jeder Zeile darf nur ein Befehl bzw. eine gültige Verknüpfung mehrerer XProfan-Befehle stehen. Ausnahme: ab XProfan 10 dürfen pro Zeile mehrerer Befehle stehen, die durch einen Doppelpunkt voneinander getrennt sein müssen. Diese Option sollten Sie erst nutzen, wenn Sie ein etwas fortgeschrittenerer XProfan-Anwender sind.

Jede Zeile darf maximal 32767 Zeichen lang sein, was wohl vermutlich kaum ein XProfaner (schon alleine aus Übersichtlichkeits-Gründen) ausreizen wird.

Leerzeilen sind zur besseren Strukturierung des Quellcodes erlaubt, diese werden vom Interpreter und Kompiler ignoriert.

Der Übersichtlichkeit wegen können Befehle (Programmzeilen) auch über mehrere Bildschirmzeilen geschrieben werden. Ist das letzte Zeichen einer Zeile ein Backslash (“\“), so wird die nächste Zeile ab dem ersten Zeichen, welches kein Leerzeichen ist, angehängt.
Beispiel:
Kompilieren Markieren Separieren

txt$ = "Das ist ein ziemlich lang"\
"er Text, der in zwei Zeilen geschrieben worden ist."

Befehle über mehrere Zeilen dürfen insgesamt jedoch auch nicht länger als 32767 Zeichen sein. Zwischen diesen Befehlen über mehrere Programmzeilen dürfen keine Leerzeilen stehen. Texte (Strings) müssen dabei jedoch stets innerhalb einer Codezeile in Gänsefüßchen (") eingeschlossen sein.

Groß- und Kleinschreibung spielen bei der Schreibweise von XProfan-Befehlen keine Rolle.

Kommentarzeilen werden durch ein führendes Hochkomma "’“ eingeleitet. Diese Zeilen werden später vom Interpreter bzw. Kompiler übersprungen, und es wird nicht versucht, sie als gültige Programmanweisungen zu interpretieren. Bei mehreren aufeinanderfolgenden Kommentarzeilen ist jede einzelne Kommentarzeile mit einem Hochkomma einzuleiten und abzuschließen (siehe Beispiel).

=== [2.2. Das Erstellen eines ersten Standard-Programmfensters] ===
Der XProfan-Befehl CLS erzeugt ein Standard-Windowsfenster mit allem drum und dran, was ein normales Windows-Fenster normalerweise zu haben hat - wie z.B. eine Titelzeile mit dem System-Menü links oben, sowie rechts oben mit den drei charakteristischen Buttons zum Maximieren, Minimieren bzw. Beenden und mit einer (vorerst nur angedeuteten) Menüzeile.
Der Befehl CLS bedeutet ClearScreen (lösche Bildschim). Wenn kein Fenster vorhanden ist, erstellt XProfan automatisch ein Standardfenster.

Tippen Sie den Befehl CLS (Klein-/Groß-/Gemischt-Schreibung ist völlig egal) in Ihre bis jetzt noch leere Datei namens Kurs001.prf ein, speichern Sie die Datei ab, und Drücken Sie die F7-Taste zum Ausführen im Interpretermodus.

Unser einzeiliges Mini-XProfan-Programm wird vom XProfan-Interpreter ausgeführt (das behaupte ich bis jetzt erst mal einfach so ...) - aber mit an Sicherheit grenzender Wahrscheinlichkeit werden sie Ihr Hauptfenster nicht bestaunen können, sondern höchstens ein kurzes Aufflackern auf ihrem Bildschirm bemerken.

Der XProfan-Interpreter hat genau das gemacht, was wir ihm bisher „gesagt“ hatten:

Erzeuge mit CLS ein Standard-Windows-Hauptfenster mit allem drum und dran (siehe oben).

Und genau das hat er getan!

Aber: Bis jetzt hatten wir dem Interpreter ja noch nicht „gesagt“, dass wir uns sein (durch unseren Mini-Code erzeugtes) Programmfenster nun endlich auch gerne mal in Ruhe anschauen würden, oder? Das müssen wir unbedingt nachholen!

Schreiben Sie also in die nächste Zeile in das Editorfenster den XProfan-Befehl: Waitinput, und sagen Sie ihm hiermit klipp und klar:

Erzeuge mit CLS ein Standard-Windows-Hauptfenster mit allem drum und dran (siehe oben).

Warte gefälligst, bis ich mir das in Ruhe angeschaut habe.

Wenn ich mit dem Anschauen fertig bin, dann teile ich es Dir mit, indem ich eine beliebige
Maustaste oder Taste auf der Tastatur drücke!
Kompilieren Markieren Separieren

Cls
WaitInput

Danach wieder speichern und per F7-Taste den Interpreter zum Ausführen unseres zweizeiligen Mini-Windows-Programmes starten.
Das Ergebnis könnte bei Ihnen in etwa so aussehen:

=== [2.3. Das Kompilieren und Linken unseres ersten Programmes] ===
Bisher konnten wir den Quellcode Kurs001.prf nur im Interpreter ablaufen lassen. Um diesen als echtes Windowsprogramm weitergeben zu können, müssen wir daraus noch eine Exe-Datei erzeugen:

Die Quellcodedatei Kurs001.prf wird dem Kompiler PROFCOMP.EXE als Aufrufparameter übergeben, der daraus zunächst den Maschinencode erzeugt, welcher in der Datei Kurs001.prc gespeichert wird (prc = profan-code). Dieser Maschinencode könnte jetzt ausgeführt werden, indem man dem Runtime PRFRUN32.EXE die Datei Kurs001.prc als Aufrufparameter übergibt.

Eine Exe-Datei wird vom Kompiler nach dem Kompilieren erzeut, indem der Maschinencode Kurs001.prf mit dem Runtime „zusammenkopiert“ (gelinkt) wird. Als Ergebnis des Linkens entsteht das fertige Windows-Programm Kurs001.exe, welches man ohne den Quellcode, ohne Interpreter, ohne Kompiler und ohne Runtime weitergeben könnte.

Die beschriebene Vorgehensweise des Kompilierens und Linkens zum Erzeugen der Exe-Datei lässt sich unter Verwendung des XProfan-Editors vereinfachen und automatisieren.

Unter dem Menüpunkt „XProfan“ finden Sie im Editor unter anderem folgende Einträge:

Ausführen (Interpreter) - F7
Der Quellcode Kurs001.prf wird zeilenweise ausgeführt.

Compilieren - F9
Aus dem Quellcode Kurs001.prf wird der Maschinencode Kurs001.prc kompiliert, woraus anschließend durch das Zusammenlinken mit dem Runtime PRFRUN32.EXE das fertige Windows-Programm Kurs001.exe entsteht.

Starten - F8
Der Maschinencode Kurs001.prc wird ausgeführt (das Kompilieren muss zuvor also bereits erfolgt sein).

Compilieren und starten - Strg+F8
Aus der Quellcode-Datei Kurs001.prf wird der Maschinencode Kurs001.prc erzeugt, woraus durch das Zusammenlinken mit dem Runtime PRFRUN32.EXE das Programm Kurs001.exe entsteht, welches zwecks Testens gleich gestartet und ausgeführt wird.

Nach der Installation hat sich der XProfan-Editor bereits automatisch konfiguriert, sofern er alle benötigten Dateien (Interpreter, Kompiler, Runtime und XProfan-Hilfedatei) im Installationsverzeichnis finden konnte.

Sollte das bei Ihrer Konfiguration nicht so sein, so wählen Sie über das Menü „Optionen“ „Allgemeine Einstellungen“ zunächst die benötigten Dateien aus und speichern Sie die Einstellungen ab.

13.12.2015 ▲

Vollständiges Zitat

Absatzweise zitieren Zeilenweise zitieren

prfBook

==== [3. Grundlagen zum Erstellen eines Hauptfensters] ====
=== [3.1. Festlegen erster Eigenschaften des Hauptfensters] ===
== [3.1.1. Position und Größe des Hauptfensters] ==

Die meisten Windows-Programme laufen in einem eigenen Fenster ab. Der im letzten Kapitel verwendete Befehl CLS ist nur ein Notbehelf bzw. eine Möglichkeit, um zum Testen auf die Schnelle ein Standard-Fenster in der Größe 640 x 480 Pixel zu erzeugen.

Der XProfan-Befehl WINDOW erzeugt ein beliebiges Programm-Hauptfenster.

Wie bei vielen XProfan-Befehlen müssen auch dem WINDOW-Befehl Parameter übergeben werden, um genauere vom Programmierer gewünschte Eigenschaften mitteilen zu können.

Im Falle des WINDOW-Befehls sind das die Bildschirmkoordinaten der linken oberen Ecke, sowie die Breite und die Höhe des zu erzeugenden Programmfensters:

Window [X1,Y1 -] X2,Y2

X1,Y1 : Wert - linke obere Ecke
X2,Y2 : Wert - Größe in Pixeln

Die Angaben für die Breite und die Höhe des zu erzeugenden Fensters beziehen sich auf die Außenabmessungen des Fensters.

Hierbei ist jedoch zu beachten:

Im Gegensatz zum kartesischen Koordinatensystem, bei dem der Koordinaten-Ursprung bei P(0,0) liegt (wie im schulischen Mathematik-Unterricht) - und wo die X-Werte von P(0,0) nach rechts und die Y-Werte von P(0,0) nach oben wachsen - ist dies beim Programmieren etwas anders geregelt.

Beim Programmieren befindet sich der Ursprung des Koordinaten-Systems grundsätzlich erst mal „links oben“ - das bedeutet also: P(0,0) ist zunächst die linke obere Ecke des Bildschirmes ( bzw. des sichtbaren Bildschirm-Bereiches).

Auf das zu erstellende Hauptfenster trifft dies (fast) ebenfalls so zu. Hier ist die linke obere Ecke P(0,0) jedoch die linke obere Ecke des beschreibbaren Fensterbereiches (auch als Client-Bereich bezeichnet), d.h. links unterhalb der Titelleiste, der Menüzeile oder ggf. einer vorhandenen Buttonbar.

Die Fensterkoordinaten:

Der folgende Code erzeugt ein windowstypisches Programmfenster, dessen linke obere Ecke sich 50 Pixel vom linken und 20 Pixel vom oberen Bildschirmrand entfernt befindet. Dieses Fenster hat eine Breite von 300 Pixel und eine Höhe von 200 Pixel.
Kompilieren Markieren Separieren

Window 50,20 - 300,200
Waitinput
end

== [3.1.2. Die Titelzeile des Hauptfensters] ==
Der Text der Titelzeile wird mit dem Befehl WindowTitle festgelegt:

WindowTitle "Mein erstes Programm"

Wichtig: WindowTitle muss zusammengeschrieben sein (ohne Leerzeichen), der Text der Titelzeile wird in Anführungszeichen gesetzt.

Grundsätzlich müssen alle vom Programm auszugebenden Texte (Fachbegriff: Strings) in Anführungsstrichen gesetzt werden. Anderenfalls versucht der Interpreter, jedes Wort des Textes als XProfan-Befehl zu interpretieren – und es hagelt Fehlermeldungen.
Kompilieren Markieren Separieren

WindowTitle "Mein erstes Windows-Programm"
Window 50,20 - 400,200
Waitinput
end

== [3.1.3. Der Fensterstil] ==

Weitere Fenstereigenschaften können durch den Befehl Windowstyle angegeben werden:

1	-	Fenster hat Vergrößerungsbox (Pfeil nach oben) und kann vergrößert werden, nur in Verbindung mit 8 möglich, entspricht ~WS_MAXIMIZEBOX/$10000
2	-	Fenster hat Verkleinerungsbox (Pfeil nach unten) und kann zum Icon werden, nur in Verbindung mit 8 möglich, entspricht ~WS_MINIMIZEBOX/$10000
4	-	Dicker Rahmen (Größe des Fensters ist veränderbar), entspricht ~WS_THICKFRAME/$10000
8	-	Fenster hat System-Menü, entspricht ~WS_SYSMENU/$10000
16	-	Fenster hat zunächst kein Menü (also auch kein ©)
32	-	Fenster benutzt Bildschirmhintergrund als Hintergrund
64	-	Das Fenster hat keine Titelzeile
128	-	Das Programm kann weder mit <Strg-Esc>, <Alt-Tab> noch <Alt-F4> verlassen werden.
256	-	Das Programm kann weder mit <Alt-F4> noch mit <Strg-Esc> verlassen werden. Umschaltung mit <Alt-Tab> ist jedoch möglich. Das Systemmenü ist wirkungslos, kann aber über MenuItem bzw. %MenuItem im Programm abgefragt werden.
512	-	Dialogfensterstil für Hauptfenster
1024	-	Das Fenster hat die Eigenschaft "ToolWindow", d.h. ein solches Fenster hat eine kleinere Titelleiste und taucht nicht in der Taskbar auf. Der Stil wirkt sowohl auf das Hauptfenster als auch auf mit Create("Window",...) erzeugte Fenster

Kombinationen werden durch Addition der einzelnen Werte erreicht. Damit der Befehl Wirkung zeigt, muss er vor dem ersten Öffnen des Programmfensters erfolgen!

„Dialogfensterstil für Hauptfenster“ (512) bedeutet:

Dialogelemente reagieren auf dem Hauptfenster ebenso wie im Dialogfenster, d.h. es kann mit TAB zwischen ihnen umgeschaltet werden, Buttons reagieren erst beim Loslassen des Knopfes, etc.

Der Windowstyle 536 ergibt sich beispielsweise aus:
8 - Fenster hat System-Menü
16 - Fenster hat zunächst kein Menü (also auch kein ©)
512 - Dialogfensterstil für Hauptfenster

536 = 8 + 16 + 512
Kompilieren Markieren Separieren

WindowStyle 536
WindowTitle "Mein erstes Windows-Programm"
Window 50,20 - 400,200
Waitinput
end

== [3.1.4. Das Hauptfenster maximieren (als Vollbild)] ==

Das Hauptfenster soll den gesamten Bildschirm ausfüllen.

„Klar, nichts ist doch einfacher als dies!“ wird manch einer denken:

„Bei 800 x 600 Pixel Grafikauflösung nehme ich: WINDOW 0,0 – 800,600, bei 1024 x 732 Pixel nehme ich WINDOW 0,0 – 1024,732, usw.“

Das klingt erst mal logisch – aber woher soll ich als Programmierer denn wissen, welche Grafikauflösung der Anwender meines Programms auf seinem System benutzt? Soll ich etwa für alle möglichen Auflösungen eine neue Programmversion erstellen?

Nein, das ist nicht erforderlich!

Jedes XProfan-Programm speichert beim Programmstart mehrere Einstellungen des Systems, auf welchem es läuft, in sogenannten Systemvariablen, so z.B. auch die horizontale und vertikale Bildschirmauflösung, die beim Programmstart auf dem System des Anwenders vorgefunden wird:

%MaxX - horizontale Bildschirmauflösung in Pixel
%MaxY - vertikale Bildschirmauflösung in Pixel

Das Prozentzeichen (das sogenannte „Präfix“) vor den Variablenbezeichnern „MaxX“ und „MaxY“ gibt an, dass in diesen Variablen ganze Zahlen (sogenannte Integerwerte) im Zahlenbereich von -32768 bis + 32767 (bis XProfan 10) bzw. von -2.147.483.648 bis +2.147.483.647 (ab XProfan 11) gespeichert werden können.

Der WINDOW-Befehl aus unseren bisherigen Programmen ändert sich also in:

WINDOW 0,0 – %MaxX,%MaxY

d.h.: “Erzeuge ein Fenster von den Bildschirmkoordinaten 0,0 beginnend (also von ganz links oben) bis zur maximalen Breite und maximalen Höhe des Bildschirmes!“
Kompilieren Markieren Separieren

WindowStyle 536
WindowTitle "Mein erstes Windows-Programm"
Window 0,0 - %MaxX,%MaxY
Waitinput
end

=== [3.2. Variablen zum Speichern von Texten und Zahlenwerten] ===

Programmierer speichern die von ihrem Programm benötigten Zahlenwerte und Texte (Strings) häufig in Variablen, um diese im weiteren Programmablauf immer wieder verwenden zu können.

Das hat den Vorteil, dass man beim nachträglichen Ändern der Zahlen oder Texte diese nur einmal (nämlich bei deren ersten Zuweisung) anzupassen braucht – und nicht in allen vorkommenden Zeilen des Quellcodes.

Jede Variable setzt sich grundsätzlich aus einem Bezeichner und einem Postfix zusammen.

Die Bezeichner der Variablen sind weitestgehend frei wählbar, sie dürfen jedoch nicht länger als 32 Zeichen sein (einschließlich Postfix) und keine deutschen Umlaute, wie „ä“, „ö“, „ü“ oder „ß“ enthalten. Leerzeichen in Variablenbezeichnern sind ebenfalls nicht erlaubt.

Zur besseren Lesbarkeit des Quellcodes (auch für eventuelle spätere Programm-Updates) sollten Sie aussagekräftige Bezeichner verwenden, so dass Sie auch noch nach Wochen und Monaten auf Anhieb Wissen, welche Werte Sie in den jeweiligen Variablen gespeichert haben.

Hinter dem Variablenbezeichner folgt das Postfix, welches angibt, welcher Wert in der Variablen gespeichert ist.

Variable	Postfix	Beispiel	Bereich
Integer	%	zahl%	-2.147.483.648 bis +2.147.483.647
LongInt	&	zahl&	-2.147.483.648 bis +2.147.483.647
Float	!	zahl!	Reelle Zahlen (Fließkomma-Zahlen) (Rechengenauigkeit: mindestens 15 Stellen)
String	$	Text$	Texte bis 2.147.483.647 Zeichen (ab XProfan 11)
Bereich	#	Bereich#	verfügbarer Speicher

Ab XProfan X2:
QUADINT			64-bit Integer (9,223,372,036,854,775,807)

Integer/LongInt
Integer-Variablen können in einem 32-Bit-System die gleichen Werte wie LongInt-Variablen haben, von -2.147.483.648 bis +2.147.483.647. Werden diese Werte über- oder unterschritten, erfolgt von XProfan zwar keine Fehlermeldung, aber die Ergebnisse werden ungewöhnlich sein.

Hinweis:
Dieser Variablentyp belegt im Arbeitsspeicher 32 Bit bzw. 4 Byte, die fix an einer Adresse nach der Deklaration über die gesamte Adresse nach der Deklaration über die gesamte Laufzeit des Programmes angeordnet sind.

Float
Auch wenn XProfan ein deutsches Produkt ist, so ist trotzdem (zwingend!) der Dezimalpunkt (statt Komma) zu verwenden – also: g! = 9.81 statt g! = 9,81.

Hinweis:
Dieser Variablentyp belegt im Speicher 64 Bit bzw. 8 Byte (Double-Format), die fix an einer Adresse nach der Deklaration über die gesamte Laufzeit des Programms angeordnet ist.

== [3.2.1. Neue-Variablentypen ab XProfan X2] ==
Ab XProfan X2 gibt es zwei neue Variablentypen: QUADINT und SINGLE.

QUADINT (kann auch QUAD oder INT64 abgekürzt werden) ist ein 64-Bit-Integer.

Die Funktionen FileSize(), DiskSize() und DiskFree() wurden erweitert und liefern nun einen QUADINT zurück. Natürlich kann das Funktionsergebnis wie bisher auch einer FLOAT-Variablen zugewiesen werden.

SINGLE ist ein 32-Bit-Fließkommawert. Der bisherige FLOAT-Typ ist ein 64-Bit-Fließkommawert und kann nun auch DOUBLE genannt werden, was dem Gebrauch in anderen Sprachen näher kommt.

Zum Rechnen mit den neuen Variablentypen:

Bislang wurden alle Rechenoperationen mit Float-Genauigkeit durchgeführt, da der Wertebereich und die Genauigkeit von Float auch die LongInts komplett umfasste.

Da ein QuadInt nun aber mehr signifikante Stellen haben kann als ein Float, mussten die Rechenregeln angepasst werden:

+, - und * werden in Float gerechnet, wenn mindestens einer der beiden Operanden ein Float oder ein Single ist,

sind beide Integertypen, wird in Quadint gerechnet.

Eine Division mit / ergibt immer einen Floatwert, eine ganzzahlige Division mit \ immer einen Quadint.

Die Bitoperationen (|, &, << und >>) unterstützen QuadInt.

Für die Vergleichs-Operatoren ist die Sache irrelevant, da dort eh immer nur 0 oder 1 herauskommt.

Die automatische Typkonvertierung sorgt dafür, dass es keine Kompatibilitätsprobleme zu früher gibt.

Hinweis: Für den Befehl INPUT sind die beiden neuen Variblentypen noch nicht umgesetzt.

== [3.2.2. Vorgehensweise bei der Verwendung von Variablen] ==
1. Jede Variable muss vor ihrer ersten Verwendung deklariert werden. Dies erfolgt durch den XProfan-Befehl Declare. Intern fordert hierdurch das Programm für diese Variable Arbeitsspeicher von Windows an und reserviert diesen.

Beispiele:
Kompilieren Markieren Separieren

Declare Titel$
Declare Preis!
Declare x%
Declare y%

oder:
Kompilieren Markieren Separieren

Declare Titel$, Preis!
Declare x%, y%

oder:
Kompilieren Markieren Separieren

Declare Titel$, Preis!, x%, y%

2. Nachdem eine Variable deklariert worden ist, kann ihr ein Wert zugewiesen werden. Dieser Wert darf im weiteren Programmablauf beliebig oft verändert werden.

Beispiele:
Kompilieren Markieren Separieren

Titel$ = „Mein erstes Programm“
x% = 300
y% = 200
Preis! = 29.99

Hinweis:
Ab XProfan 10.0 kann das Deklarieren von Variablen und derer erste Wertzuweisung mittels des Var-Befehles vereinfacht geschrieben werden, ohne dass jeweils zuvor explizit Speicher durch Declare von Windows angefordert werden muss:

Beispiele:
Kompilieren Markieren Separieren

var Titel$ = "Mein erstes Windows-Programm"
var x% = 300
var y% = 200
var Preis! = 29.99

Unser obiger Programm-Code sähe damit wie folgt aus:
Kompilieren Markieren Separieren

Declare Titel$
Titel$ = "Mein erstes Windows-Programm"
WindowStyle 536
WindowTitle Titel$
Window 0,0 - %MaxX,%MaxY
Waitinput
end

Ab XProfan 10 wäre auch kürzer möglich:
Kompilieren Markieren Separieren

var Titel$ = "Mein erstes Windows-Programm"
WindowStyle 536
WindowTitle Titel$
Window 0,0 - %MaxX,%MaxY
Waitinput
end

Ausblick:
In XProfan gibt es noch einen weiteren Variablen-Typ namens Bereich.
Diese Variable ist ein Zeiger auf einen Datenbereich. Man könnte auch sagen, sie ist ein Handle für einen Datenbereich.
Mit diesem Variablen-Typ werden wir uns in späteren Kapiteln näher beschäftigen. {LINK}

== [3.2.3. Neue Variablen-Syntax ab XProfan X2] ==

Im Zusammenhang mit der Einführung der neuen Variablentypen QUADINT und SINGLE musste nicht nur der "Unterbau" auf die neuen Variablentypen-Typen vorbereitet werden, sondern unter anderem auch die Syntax.

Bislang wurde der Typ einer Variablen wie im klassischen Basic durch ein Postfix, dem letzten Zeichen des Variablennamens, definiert: !, %, &, $ oder #. Der Parser war also genau darauf ausgelegt, er erkannte und unterschied die Variablen also an diesem Postfix.

Nun stellte sich die Frage, was für Postfixe könnte man denn noch benutzen? Schließlich sollen die Zeichen auf der Tastatur leicht erreichbar sein. Da blieben noch solche Zeichen wie °, § und €.

Ein Problem: Auf internationalen Tastaturen gibt es die Zeichen teilweise nicht.

Das Hauptproblem: Danach wäre aber Schluß.

Die jetzige Lösung: Abkehr vom Postfix. Dazu musste der Parser komplett umgeschrieben werden und auch noch einige Befehle und Funktionen, die Variablennamen als Parameter verlangen (etwa CLEAR, DISPOSE, DECLARE, PARAMETERS, CLASSOF, SIZEOF, etc.). Außerdem braucht es für Variablennamen ohne Postfix noch eine neue Syntax, um den Typ zu bestimmen. Und 100%ig kompatibel zur bisherigen Syntax sollte es auch sein.

So sieht die Lösung aus:

Declare <Typ> <Name>[, <Name>[,...]], <Typ Name>, ...
Parameters <Typ> <Name>[, <Name>[,...]], <Typ Name>, ...
Var <Typ> <Name> = <Wert>

Die bisherigen Typen heißen STRING, INTEGER, LONGINT, FLOAT und MEMORY (und können auch mit INT, LONG und MEM abgekürzt werden). Statt FLOAT kann man auch DOUBLE schreiben:
Kompilieren Markieren Separieren

Declare MEMORY b, STRING s, LONGINT l, FLOAT f

Bei mehreren Variablen gleichen Typs direkt hintereinander reicht die einmalige Nennung des Typs:
Kompilieren Markieren Separieren

Declare INT x, y, z, STRING Zeile1, Zeile2

Der Typ einer Variablen wird entweder durch ein Postfix oder durch einen Typkennzeichner bestimmt. Beides zusammen geht nicht.

Neue und bisherige Syntax können beliebig gemischt werden. Zu beachten ist natürlich, dass bei Variablen mit Postfix dieses Zeichen Teil des Namens ist. So waren ja bislang schon X$, X&, X%, X! und X# unterschiedliche Variablen, die sich durch das Postfix unterschieden. Also werden künfig auch STRING X und X$ zwei verschiedene Variablen sein.

Da ein Variablenname nicht doppelt vorkommen darf, wird es natürlich nicht gleichzeitig einen STRING X und einen LONGINT X geben dürfen.

Wichtig: Für die Elemente einer Struktur oder einer Klasse bleiben die bisherigen Regeln bestehen. Hier können vorerst keine Typbezeichner verwendet werden.

== [3.2.4. Übergabe von Strings und Fließkommawerten an APIs und DLLs ab XProfan X2] ==

Fließkommawerte und -variablen werden grundsätzlich als 32-Bit-Single übergeben. Hierbei ist es unerheblich, ob die Variable eine FLOAT oder SINGLE ist. Nötigenfalls wird konvertiert.

Es können jetzt nicht nur Stringliterale, sondern auch Stringvariablen und -ausdrücke direkt ohne ADDR() übergeben werden. Im Falle eines Strings wird automatisch die Adresse an die externe Funktion weitergereicht. (Natürlich schadet ein ADDR() auch nicht, so dass die Kompatibilität gewahrt bleibt.)

Hinweis: Obiges gilt für alle Aufrufe externer Funktionen mit Ausnahme der mit DEF definierten externen Funktionen (also für EXTERNAL, CALL, IMPORTDLL undf IMPORTFUNC).

== [3.2.5. Die interne Verwaltung der Variablen ab XProfan X2] ==

Hier handelt es sich um die komplexeste Änderung in der Version XProfan X2.
Profan gibt es nun schon seit über 20 Jahren. Zunächst gab es nur Integer- und Stringvariablen, später kamen Longint, Float und noch später die Bereiche hinzu. Dann wurden Arrays eingeführt und letztendlich auch dynamische Arrays ...

Man sieht dem Quellcode von XProfan an, dass er "gewachsen" ist und ein Ausbau dem nächsten folgte. Entsprechend aufwändig war inzwischen die Variablenverwaltung programmiert. Jeder "Anbau" wurde komplizierter und unübersichtlicher ...

Um die Möglichkeit zu schaffen, neue Variablentypen einzubauen, wurde nun die komplette Verwaltung der Variablen völlig neu organisiert und geschrieben. Waren bislang ca. 17 Datenarrays nötig, die Variablen zu speichern und mussten 15 Zeiger auf diese Arrays bei jedem Einsprung und Ausgang einer Prozedur oder Funktion verwaltet werden, so reduziert sich das nun auf zwei Datenarrays und zwei Zeiger: einer für einfache Variablen und einer für Arrays. Und während bislang ein neuer Datentyp zu drei neuen Datenarrays und 3 neuen Zeigern und deren Verwaltung führte, ändert sich in dieser Hinsicht durch neue Datentypen nichts mehr.

=== [3.3. Handles von Windows-Objekten] ===
Was ist ein Handle?

Jedes Objekt, welches auf dem Windows-Bildschirm erzeugt wird (Programmfenster, Buttons, Eingabezeilen, Listboxen, etc.), muss von Windows eindeutig identifiziert werden können, denn meistens soll beim Aktivieren dieser Objekte (z.B. durch Mausklick) eine Aktion ausgelöst werden.

Zu diesem Zweck vergibt Windows jedem Objekt intern eine Nummer (Zahl), durch die das Objekt eindeutig zugeordnet werden kann. Diese Zahl bezeichnet man als Handle (engl. „Griff“), über welches auf das Objekt zugegriffen werden kann. Der genaue Zahlenwert eines Handles ist für den Programmierer uninteressant, denn darum möge sich Windows gefälligst selber kümmern, zumal dieser Wert sowieso bei jedem Windows- bzw. Programmstart unterschiedlich ist. Wichtig ist nur, dass nicht zwei unterschiedliche Objekte von Windows den gleichen Zahlenwert zugewiesen bekommen.

Der Programmierer kann jedoch die Handles der Objekte seines Programms in Variablen speichern, um über diese Variablen auf die Objekte zugreifen zu können, wenn er z.B. durch das Anklicken eines Buttons eine Aktivität auslösen möchte.
Auch das Hauptfenster eines XProfan-Programmes bekommt von Windows ein Handle zugewiesen. Dieses Handle des Hauptfensters wird von XProfan automatisch in der Systemvariablen %HWnd gespeichert.

=== [3.4. Der Client-Bereich des Hauptfensters] ===
Der Client-Bereich ist der Bereich eines Fensters, der mit Grafikbefehlen beschreibbar ist, in den z.B. Grafiken geladen oder Buttons, Eingabezeilen, etc. platziert werden können. Dieser „beschreibbare“ Fensterbereich ist kleiner als die äußeren Abmessungen des Fensters, wie sie z.B. mit dem Window-Befehl festgelegt worden sind. Denn von diesem äußeren Bereich sind mindestens die Breite der äußeren Ränder und oft auch die Höhe der Titelzeile und einer eventuell vorhandenenen Menüzeile abzuziehen, um den wirklich beschreibbaren Client-Bereich ermitteln zu können.

Zur Bestimmung der Abmessungen gibt es die XProfan-Funktionen Width und Height.

Width(H[, M])

H: LongInt - Handle des Fensters, Dialoges, Dialogelementes
M: Integer - Modus: 0 = innen / 1 = außen

Height(H[, M])

H: LongInt - Handle des Fensters, Dialoges, Dialogelementes
M: Integer - Modus: 0 = innen / 1 = außen

Oftmals benötigt man zum Zeichnen die Größe des Fensters bzw. Dialoges innerhalb des Rahmens (so einer vorhanden ist). Diese Fläche wird auch der Client genannt. Bei einem Fenster schließt diese Fläche Menü und Titelleiste nicht mit ein, sondern es wird nur der Teil ausgemessen, der auch tatsächlich zum Malen, Schreiben, etc. genutzt werden kann. Das wäre der Modus 0 (innen).
Möchte man hingegen die Größe des ganzen Fensters haben, ist der Modus 1 (außen) anzuwenden.

=== [3.5. Weitere Eigenschaften von Hauptfenstern] ===

Nach diesem kurzen Exkurs zum Thema Variablen und Handles wenden wir uns zunächst weiteren Gestaltungsmöglichkeiten für Hauptfenster zu.

== [3.5.1. Das Hauptfenster zentrieren] ==

Das Hauptfenster meines Programms soll immer genau in der Mitte des Bildschirms platziert sein, wenn es kleiner als die eingestellte Bildschirmauflösung ist.

Dafür benötigen wir zunächst die x-Koordinate der linken oberen Ecke des Programmfensters.
Diese ergibt sich als Differenz aus Bildschirmbreite %MaxX und Breite des Hauptfensters x%, dividiert durch 2:

(%MaxX – x%) : 2

Analog erhalten wir die y-Koordinate der linken oberen Ecke des Programmfensters als Differenz aus Bildschirmhöhe %MaxY und Höhe des Programmfensters, dividiert durch 2:

(%MaxY – y%) : 2

In XProfan gibt es für die Grundrechenoperationen entsprechende Operatoren:
Addition: c% = a% + b%
Subtraktion: c% = a% - b%
Multiplikation: c% = a% * b%
Division: c% = a% / b%

Beispiele für zusammengesetzte Terme:
d% = a% * (b% - c%)
d% = a% - (b% + c%)
d% = a% / (b% - c% + d%)
Auf unser Beispiel bezogen:

(%MaxX – x%) / 2
(%MaxY – y%) / 2
Kompilieren Markieren Separieren

Declare x%,y%,Titel$
x% = 500
y% = 400
Titel$ = "Mein erstes Programm"
WindowTitle Titel$
Windowstyle 536
WINDOW (%MaxX – x%) / 2,(%MaxY – y%) / 2 – x%,y%
Waitinput
end

Ab XProfan 10 ist es auch möglich, die vereinfachte Variablendeklaration und Wertzuweisung mit var zu verwenden:
Kompilieren Markieren Separieren

var x% = 500
var y% = 400
var Titel$ = "Mein erstes Programm"
WindowTitle Titel$
Windowstyle 536
Window (%maxX-x%)/2,((%maxY-y%)/2) - x%,y%
Waitinput
end

== [3.5.2. Die Hintergrundfarbe des Hauptfensters festlegen] ==

Nachdem ein Hauptfenster mit dem Window-Befehl erzeugt worden ist, kann die Hintergrundfarbe mit dem Befehl cls eingestellt werden. Der cls-Befehl erwartet in diesem Fall als Parameter einen Farbwert, welcher durch die Funktion rgb eingestellt wird. Die rgb-Funktion errechnet je nach eingestelltem Farbmodus einen Farbwert aus den Farbanteilen rot, grün und blau.

cls rgb(rot%,gruen%,blau%)

Beispiele:
Kompilieren Markieren Separieren

cls rgb(0,0,0)'schwarz
cls rgb(255,0,0)'rot
cls rgb(0,255,0)'grün
cls rgb(0,0,255)'blau
cls rgb(255,255,0)'gelb
cls rgb(192,192,192)'grau

Kompilieren Markieren Separieren

var x% = 300
var y% = 200
var Titel$ = "Mein erstes Programm"
WindowTitle Titel$
Windowstyle 536
Window (%maxX-x%)/2,((%maxY-y%)/2) - x%,y%
cls rgb(255,0,0)
Waitinput
end