|
VisKProg (alter Name ist "Visual 'K'" ) ist eine Programmiersprache
für KDE, die für Programmierneulinge gedacht ist.
Dieses Handbuch ist für Version 0.1.6 von
Christoph Pinkel und
Rainer Jochem erstellt
worden.
Wir wünschen Dir nun viel Spaß mit diesem Handbuch und hoffen, daß Du eines Tages
ein großartiger Programmierer wirst :-)
Warnung
VisKProg ist unstabile alpha - Software, d.h. es sind zum einen nur Teile der
geplanten Funktionen bereits vorhanden und die vorhandenen Programmteile sind u.U. noch
mit Fehlern behaftet. Wir können daher keinerlei Gewährleistung für alle möglichen (und
unmöglichen) Fehler, Probleme, und andere Abnormalitäten übernehmen.
Es gilt eben das "NO WARRANTY"-statement der GPL 2,
unter der VisKProg steht.
Vorbereitung
Bevor Du damit beginnen kannst, dein eigenes KDE-Programm mit VisKProg
zu erstellen, solltest Du einige Programme installieren:
Zuallererst natürlich VisKProg, d.h. die Pakete VKBase und VKIDE. Wenn Du ohne
Probleme VKIDE kompilieren und installieren kannst, so ist
ziemlich alles, was Du benötigst bereits installiert.
Falls Du beim Ausführen von ./configure bei VK-IDE Probleme bekommen
solltest, mußt Du in der Fehlerausgabe von ./configure nachsehen, welche Programme
Du noch benötigst.
Desweiteren musst Du die Gnu automake und autoconf
Tools installiert haben (Diese sollten bei Deiner Distribution
in einem Paket Namens "automake" oder "autoconf" - oder so
ähnlich - mitgeliefert worden sein).
Danach kannst Du damit beginnen, dein eigenes Projekt
zu erstellen, indem Du unser neues vkNewProject-Tool verwendstn.
Dieses benötigt als Information von Dir lediglich eine Angabe eines
Zielverzeichnisses (i.A. dein home-Directory) und einen Namen für das Projekt.
Da in der Regel alle KDE-Programme mit einem 'K' beginnen, sollte Dein Projekt dies
nach Möglichkeit auch tun. Weiterhin sollte der Projektname keine Sonderzeichen und vor allem
keine Leerzeichen enthalten. Nun kannst Du mit Deiner Arbeit als Programmierer beginnen :-)
Um Dir die Arbeit noch weiter zu erleichtern, verfügt diese Version über eine weitere Hilfe
zur Erstellung Deines Projektes: Wenn Du dein soeben mit vkNewProject angelegtes Projektverzeichnis
öffnest und dort in das source-Verzeichnis wechselst, so wird (bei eingeschalteter html-Ansicht in
kfm) eine - allerdings englische (aber einfach verständliche) - html-Seite erscheinen, die
das Ausführen grundlegender Befehle per Mausklick ermöglicht. (Um den Rest des source-Verzeichnisses
einzusehen, muss die html-Ansicht in kfm allerdings abgeschaltet werden)
Zu diesem Zeitpunkt sollten wir einmal festlegen, was mit einem
VisKProg - Projekt gemeint ist: Es handelt sich dabei um ein Programm,
geschrieben in VisKProg, mit allen Entwickler-Dateien (besonders dem Quellcode) und
mit einem Unterverzeichnis für das dazugehörende KDE-Projekt,
wobei ein KDE-Projekt ein in c++ geschriebenes Programm ist und in
unserem Fall automatisch aus den VisKProg - Quellen erstellt wird.
In jedem Falle brauchen wir dieses c++/KDE-Projekt, da andere
Leute es zur Installation Deines Programmes auf deren PC's benötigen.
Kapitel 1: "Hello world!"
Bereite Dich sich nun auf das grauenvollste Programm vor, das je das
Licht der Welt erblickt hat: "Hello world!" :-) Da so ziemlich
jedes Programmiersprachenhandbuch mit einem "Hello world!" -
Programm beginnt, wollen wir es, als Verfasser eines ordentlichen
freeware-Projektes, mit diesem Handbuch genauso halten.
Unser "Hello world" soll ein kleines Fenster zeigen, das wie das
folgende aussieht, und dessen einzige Funktion im Schließen des
Fensters besteht, wenn der Benutzer auf den OK-Knopf klickt.
Get ready!
Wenn Du die Instruktionen im Abschnitt "Vorbereitung" befolgt hast,
so solltest Du nun über ein Verzeichnis "khelloworld" in Deinem
Home-Verzeichnis verfügen, das eine Vorlage eines (nahezu leeren) VisKProg -
Projektes enthält. Solltest Du dein Verzeichnis noch nicht in
"khelloworld" umbenannt haben, so ist jetzt die Gelegenheit dazu.
Öffne nun KFM und wechsele in das Verzeichnis
"~/khelloworld/source/VK/win". Dies ist das Verzeichnis, das den
Quellcode des Standard "main"- Fensters (genannt "win") und die
Quellen (engl.source) aller Aktionen / Ereignisse, die zu diesem Fenster gehören,
enthält. (Der englische Begriff "source" ist eine Abkürzung für
"source code" - Quellcode - was bedeutet, daß eine Datei die "Kommandos", die
Ihr Programm benötigt, enthält)
Öffne also eine Terminal-Emulation (console oder kvt) und
wechsle in dasselbe Verzeichnis. Anschließend öffnest Du die
Fensterdatei "win.vktf" mit dem VisKProg GUI builder ("kwinedit"). Du
erhälst dann eine Editor-Ansicht ähnlich der folgenden:
Ein Fenster erstellen
KWinedit ist kein echter WYSIWYG (What You See Is What You Get -
übersetzt etwa: Was Du siehst, ist was Du bekommst ) Editor, d.h. das
ausgeführte Programm wird ein wenig anders aussehen wie das, welches Du
im Editor siehst; zerbrech' Dir also nicht den Kopf über das etwas
ungewöhnliche "look & feel".
Für unser "Hello world", müssen wir
also den Text "Hello world" und einen OK-Knopf hinzufügen und wir
wollen den Text in der Titelzeile von "New Window" in "Hello!"
ändern.
Jedes Element in einem Fenster, wie Schaltflächen, Textfelder (diese
werden als labels bezeichnet) wird als widget
bezeichnet, so wie Fenster selbst widgets darstellen.
Um einem Fenster ein widget hinzuzufügen, musst Du nur das entsprechende
widgets-"tool" aus dem "Tool"-Menu auswählen und dann ein widget in Dein
Fenster zeichnen, so wie man einen Gegenstand in einem Zeichenprogramm
zeichnet.
Wähle zuerst "Label", um ein Textlabel in die Mitte des Fensters
zu zeichnen und dann "Button", um die "Ok"-Schaltfläche zu zeichnen.
Wenn Du dies getan hast, so willst Du möglicherweise den Text des
labels vom standartmäßigen "New text label" in "Hello world" und den
der Schaltfläche von "New button" zu "OK" ändern.
Dazu musst Du wissen, daß das Erscheinungsbild aller widgets durch
ihre properties (Eigenschaften) bestimmt wird. Klicke mit
der rechten Maustaste auf ein widget Deiner Wahl und gehe zum
Menupunkt "Edit properties" des Kontextmenus. Wenn Du (zum Beispiel)
auf Deine Schaltfläche geklickt hast, öffnet KWinedit einen Dialog,
ähnlich dem folgenden:
Links siehst Du die Namen der verschiedenen Eigenschaften, auf der rechten
Seite deren Werte (property values).
Die Eigenschaft, die den Text beeinflußt heißt "Caption". Klicke
also auf den kleinen "." - Knopf neben dem Wert von "Caption", um den
Text in "OK" abzuändern. Du solltest ebenfalls "Name" in einen Wert
wie etwa "ok" abändern. Die Eigenschaft "Name" kontrolliert den
widget-Namen. Ein Name wird innerhalb von VisKProg verwendet und ist
von großer Bedeutung, wenn Du diesem widget eine Funktion (wie etwa
Verlassen des Programms, wenn der Benutzer auf die Schaltfläche klickt)
zuordnen möchtest.
Du solltest einen kurzen Namen wie "ok", "button" oder "okbutton"
wählen, der das widget beschreibt. Wenn Du damit fertig bist,
verändere die Eigenschaften Deines Labels, besonders den Wert von
"Caption" (ändere dies in "Hello world!"). Nach alldem willst Du
sicherlich die "Caption" des Fensters (den Text der Titelzeile) noch
ändern. Klicke hierzu in den Hintergrund des Fensters, wähle
mit der rechten Maustaste "Edit properties" und ändere den Wert von
"Caption" zu "Hello!".
Übersetzen, kompilieren, ausführen, ...
Um zu sehen, ob alles funktioniert, musst Du das Programm
Übersetzen, kompilieren und ausführen. Übersetzen bedeutet,
daß von dem VisKProg - Projekt ein c++ / KDE - Projekt erstellt wird.
Kompilieren bedeutet, daß aus dem KDE - Projekt ein ausführbares
Programm erstellt wird.
Klingt kompliziert? Das einzige was Du machen musst, ist in das
Source-Verzeichnis Deines Projektes (~/khelloworld/source) zu wechseln und
auf "compile and run" zu klicken.
"run" erledigt all diese Aufgaben für Dich, oder genauer, es startet
zuerst "make" (zur Übersetzung) und "make run" (zum Kompilieren und
Ausführen). Wenn Du lediglich wissen möchtest, ob Dein Programm korrekt
übersetzt wird (und es nicht ausführen möchtest), so brauchst Du nur
"make" im Verzeichnis der *.vktf window-Datei auszuführen.
Programmcode hinzufügen
Es gibt immer noch eine Sache, die wir bis jetzt noch nicht in unser
Programm eingefügt haben: Das Verlassen des Programms, wenn der
Benutzer auf die "OK"- Schaltfläche klickt.
Gewissermaßen kann man sagen, daß wir jetzt damit beginnen, das
Programm zu schreiben.
VisKProg bietet dem Programmierer Events (Ereignisse) und
Functions (Funktionen) zur Erstellung eines Codes an. Während
Functions vom Programmierer ausdrücklich von irgendeiner Stelle aus dem
Programm heraus aufgerufen werden müssen, so starten Events
automatisch, wenn das Ereignis, das von diesem Event beschrieben wird,
eintritt (In unserem Fall: "Der Benutzer hat auf die "OK"-Schaltfläche
geklickt"). Jede Funktion und jedes Ereignis ist in einer eigenen
Datei mit der Endung "*.vk" im Verzeichnis des Fensters, zu dem sie
gehört, abgelegt. Da unser Event zu der Schaltfläche "ok" gehört, die
selbst zum Fenster "win" gehört, müssen wir dieses in dem aktuellen
Verzeichnis ("win") abspeichern. Der Eventname und der Dateiname sind
gleich; sie beschreiben das Event in der folgenden Form:
widgetname'_'eventname . Wenn Du deine Schaltfläche "ok"
genannt hast, ist der komplette Dateiname
"ok_click.vk" .
Klicke nun mit der rechten Maustaste auf Deine "OK"-Schaltfläche
und wähle den Menupunkt
"Edit Events" -> "click()".
Nun
öffnet sich automatisch der VisKProg source code editor
(Quellcode-Editor - ksrcedit). Schreibe nun den folgenden
Text hinein:
Event ok_click()
{
}
Falls Du die Schaltfläche anders als "ok" genannt hast, so musst
Du sowohl den Dateinamen, als auch den Eventnamen in
Name_Deiner_Schaltfläche_click umändern und die Datei unter dem
korrekten Namen (Schaltflächenname_click.vk) im Verzeichnis unseres
Fensters abspeichern.
Nimm diesen Code fürs erste "so wie er
ist" zur Kenntnis - Du wirst ihn später verstehen - und sollte Dich
ksrcedit über "Syntax errors" oder ähnliches warnen, überprüfe,
ob in Deinem Code irgendetwas falsch ist, aber mach' Dir keine
Sorgen: in der derzeit aktuellen Version hat ksrcedit ab und an
eigene (etwas eigenwillige) Vorstellungen, was ein korrekter
VisKProg-code ist.
Wenn Du detailiertere und bessere Fehlermeldungen erhalten möchtest,
so musst Du die Fensterspezifische Konfigurationsdatei "win.vkc"
(mittels "Edit -> Reload *.vkc file") in den Quellcode-Editor laden.
Falls es noch keine win.vkc-Datei gibt,
erstelle diese durch Eingabe von "make" in Deinem Terminal.
Benutze nun das ./run - Kommando erneut und teste Dein erstes Programm!
Kapitel 2: "Hello world" Version 2.0
Nun möchten wir, daß sich unser "Hello world" - Programm etwas aktiver
verhält: Wir fügen eine "About" - Schaltfläche neben die "OK" -
Schaltfläche ein und das Programm soll nun fragen, ob es wirklich
beenden soll, wenn der Benutzer auf "OK" geklickt hat.
Der "about" - Dialog
Öffne win.vktf in KWinEdit erneut und ändere Größe
und Position der "Ok" - Schaltflächte so ab, daß noch eine zweite
Schaltfläche daneben paßt.
Wenn Du damit fertig bist, füge noch eine neue Schaltfläche ein,
ändere deren Namen in "about" und deren Caption zu "About".
Wie Du weißt, benötigst Du eine Event-Datei, wenn Du die
neue Schaltfläche dazu veranlassen willst, etwas zu tun,
und da die Schaltfläche "about" heißt und wir das
"click" - Event bearbeiten möchten, lautet der Dateiname
"about_click.vk". Öffne also wieder mit der
rechten Maustaste über "Edit event -> click" den source code
editor und füge den folgenden Code hinzu:
Event about_click()
{
}
Du siehst, daß diese kleine Event viel mit unserem ersten ok_click() -
Event gemeinsam hat. Dies liegt daran, daß jede Funktion und jedes
Event eine exakt definierte Struktur besitzt. Wir wollen nun zeigen,
was die einzelnen Teile bedeuten:
- Event: Dies zeigt an, daß das folgende ein
Event und keine Funktion ist
- about_click: Dies ist der Name des Events. Er hat
die Form widget-name_event-name, und da
unser widget die Schaltfläche mit dem
Namen "about" und dem "click" - Event ist,
lautet der Eventname "about_click".
- (): Die leeren Klammern zeigen an, daß dieses
Event keine Argumente übernimmt.
Argumente verhalten sich wie
Kommandozeilenargumente (z.B. "ls" mit der "-l"
Option: "ls -l"): Sie stellen dem Event oder
der Funktion eine Zusatzinformation zur
Verfügung. Wenn eine Funktion oder ein Event
Argumente übernimmt, so werden diese in der
Klammer aufgeführt, andernfalls (wie in unserem
Fall) bleibt die Klammer leer.
- Die gesamte erste Zeile ("Event about_click()") wird als
Event - Deklaration bezeichnet.
- {
}: Dies ist der Haupt - code block des
Events. Ein Code-Block ist eine Anzahl von
commands (Kommandos), die von '{' '}'
umschlossen werden, in diesem Event zero
commands (leere Kommandos).
Wenn Du das Event nun dazu veranlassen willst, etwas zu tun, so
musst Du commands hinzufügen. Es gibt verschiedene Arten von
Kommandos, das was Du bereits kennst, ist der (vordefinierte)
function call (Funktionsaufruf). Erinnern wir uns: Eine Funktion
ist wie ein Event, aber der Programmierer muß sie durch ein Kommando
aufrufen, oder genauer durch einen function call. Und da es eine
Vielzahl von "Standardaufgaben" gibt, die von einer Vielzahl von
Programmen verwendet werden, verfügt VisKProg über eine Vielzahl von
sogenannten vordefinierten Funktionen, d.h. Du musst die Funktion
nicht mehr selbst schreiben, sondern diese ist bereits verfügbar und
muss von Dir lediglich noch aufgerufen werden.
Im ersten Event ("ok_click") hast Du bereits einen solchen function call verwendet:
Exit();
Exit ist eine vordefinierte Funktion; "()" zeigt an, daß
Du dieser Funktion keine Argumente übergibst (d.h. sie nimmt keine
Argumente) und das Semikolon ";" beendet das Kommando. Das Semikolon
steht grundsätzlich am Ende jedes Kommandos, um das Ende
abzugrenzen.
Da ein Klick auf die "About" - Schaltfläche ein Fenster mit einer
kleinen Mitteilung öffnen soll, so müßten wir deshalb ein neues
Fenster erstellen. Da dies aber viel Zeit kostet, benutzen wir einen
kleinen Trick: Es gibt eine einfache vordefinierte Funktion in
VisKProg, die dazu erstellt wurde, kleine Dialoge mit nur einem
Mitteilungstext und einigen einfachen Schaltflächen (wie "OK" oder
"Yes" oder "No") zu zeigen. Diese Funktion heißt "MsgBox" und
übernimmt drei Argumente: Den Mitteilungstext, eine ID, die angibt,
welche Schaltflächenkombination zu benutzen ist, und den Text der
Titelzeile des Fensters. Diese Argumente werden innerhalb der
Klammern, durch ',' getrennt, aufgeführt.
Die Syntax von "MsgBox" lautet wie folgt:
MsgBox ( Mitteilungstext,
Schaltflächen_ID, Caption_der_Titelzeile
);
Ich verwendete z.B. den Mitteilungstext "Hello world 2.0\n\n(c)
Christoph Pinkel", die Schaltflächen-ID '0' ( 0 ==> zeigt nur eine
"OK"-Schaltfläche ) und den Wert der Titelzeile "About".
Mein function call lautet daher
MsgBox( "Hello world 2.0\n\n(c) Christoph Pinkel", 0,"About");
Das Event sieht dann wie folgt aus:
Event about_click()
{
MsgBox( "Hello world 2.0\n\n(c) Christoph Pinkel", 0, "About" );
}
H I N W E I S: Die "\n" - Folge in meinem Text wird als escape
sequence bezeichnet, und die escape sequence "\n" ist das Zeichen für eine
neue Zeile. (H I N W E I S: Leider können diese escape sequences zur Zeit noch nicht
verwendet werden, da der source code editor Probleme mit dem '\' hat :-( ...)
Ändere nun Deine about_click.vk - Datei ab,
speichere diese und versuche Dein Projekt mit ./run
auszuführen.
Was wir noch nicht eingefügt haben, ist der "Really quit?" - Dialog im
"ok_click" Event. Öffne daher die Datei ok_click.vk und ändere
die Kommandos im Code-Block in:
a = MsgBox( "Really quit ?", 2, "Hello world" );
If a == 1 Then Exit();
Dies waren jetzt viele neue Befehle auf einmal: Zuallererst
überbrachten wir einen return value von der MsgBox-Funktion zur
variable "a". Dann haben wir den Wert von "a" mit dem Wert "1"
verglichen und dem Computer erklärt, daß er nur dann das Programm
verlassen soll, wenn diese Werte gleich sind.
-
"Return values" (Rückgabewerte) stellen eine spezielle Eigenschaft von
Funktionen dar. Genauso, wie diese Argumente entgegenehmen können, so
sind Funktionen in der Lage, sogenannte "return values"
zurückzugeben, um demjenigen, der die Funktion aufgerufen hat,
spezielle Informationen zu liefern. Im Falle der MsgBox kehrt die
Funktion mit der Zahl der Schaltfläche zurück, die der Benutzer
gedrückt hatte. Und bei einer Yes-No-MsgBox, die wir mit der
Schaltflächen-ID "2" als zweites Argument erstellt hatten, trägt die
"Yes" - Schaltfläche die Nummer 1 (d.h. MsgBox gibt den Wert "1"
zurück, wenn "Yes" gedrückt wurde). In unserem MsgBox-Aufruf von oben
(im about_click Event) kümmerten wir uns deshalb nicht um den
Rückgabewert, da es für den Benutzer keine Auswahl gab (und es zudem
uninteressant ist, zu überprüfen, ob "OK" oder "OK" gedrückt wurde
:-)), und aus diesem Grund kehrte MsgBox mit seinem Rückgabewert nach
Nirgendwo zurück.
-
Eine Variable in VisKProg ist eine "Stelle" im Speicher, wo
Daten temporär "gespeichert" werden können. Du kannst hierbei jeden beliebigen
Namen, der aus alphanumerischen Zeichen und Unterstrichen ('_')
zusammengesetzt ist, als Variablennamen verwenden, wenn er mit einem
Buchstaben des Alphabets beginnt. (z.B. a, b, c, i, ii, X, Y,
myVar1, return_value, usw.) Namen, die mit einem Unterstrich oder
einer Zahl ( _v oder 1st_var) beginnen, können nicht verwendet werden.
Es gibt keinen Zwang, Variablen ausdrücklich zu deklarieren,
aber nicht deklarierte Variablen verlieren ihren Wert, wenn das Event
oder die Funktion, in der diese benutzt werden, beendet wird. D.h.
wenn ein Event zweimal aufgerufen wird, ist in beiden Fällen die
Variable "leer", wenn sie zum ersten Mal im Event / Funktion auftritt.
Weiterhin kannst Du nicht den Wert einer Variablen eines anderen
Events kontrollieren: Wenn Du z.B. die Variable "a" in zwei Events
verwendest, so sind dies zwei unterschiedliche Variablen mit
unterschiedlichen Werten.
-
Du hast weiterhin die Möglichkeit, den Wert
einer Variablen wann Du willst zu ändern, indem Du die
set-to-operation verwendest. Set-to-Operationen sind eine
weitere Art von Kommandos, die die Form Variablenname =
Neuer_Wert; besitzen.
Eine korrekte Set-to-Operation wäre "x=1.1", "pi = 3.141592;" ,
" my_String = "Hello!"; " oder "i = 0;".
Unser "a = MsgBox ..." - Kommando ist ein mixed command.
Es ist eine Set-to-Operation, aber der neue Wert ist der Rückgabewert
einer Funktion (MsgBox). Es handelt sich also gewissermaßen auch um
einen Funktionsaufruf.
-
Das "If..." - Kommando ist ein weiterer Kommandotyp: Es ist ein base
command (Grundlegendes Kommando), d.h. ein Kommando mit eigener
Syntax, die sich von der anderen Syntax unterscheidet. Es gibt nur
wenige base commands, aber diese werden sehr häufig verwendet. Die
Syntax von "If" lautet:
If Bedingung Then
Auszuführendes_Kommando;
Das Auszuführende_Kommando wird nur dann ausgeführt, wenn die
Bedingung wahr, d.h. erfüllt ist. Beachte bitte, daß Du "==" zum
Vergleich zweier Werte und nicht "=" verwenden musst. Es gibt einen
kleinen Unterschied zwischen "=" und "==":
'=' wird benutzt, um Variablenwerte zu setzen a
, "==" vergleicht zwei Variablen, ohne deren Wert zu ändern.
Ändere nun Deine ok_click.vk - Datei wie folgt ab und
versuche, diese anschließend mit ./run auszuführen:
Event ok_click()
{
a = MsgBox( "Really quit ?", 2, "Hello world" );
If a == 1 Then
}
Kapitel 3: Ein kleiner Taschenrechner
Das Arbeiten mit Eigenschaften
Wie Du siehst ist das Erstellen eines VisKProg-codes nicht sehr schwierig.
Es ist aber notwendig, daß ein Programm "aktiv" ist.
Ein wichtiger Teil im Code von GUI basierten Programmen (GUI = Graphical User Interface =
"Graphische Benutzerschnittstelle" - gemeint ist die graphische Oberfläche) ist immer
das folgende: Das Ändern von widget-Eigenschaften zur runtime (Laufzeit) eines Programmes.
Wenn der Benutzer irgendetwas getan hat, so soll das Programm oftmals darauf reagieren, indem
im Fenster irgendwelche Unterschiede auftreten.
Folgendes einfaches Beispiel: Du hast ein Fenster mit einem Textlabel und einem OK-Button
und Du willst, daß die Caption des Textlabels von "Klicken Sie auf OK" zu "Danke!" wechselt,
sobald der Benutzer auf "OK" geklickt hat.
KSimpleCalc
Als erste komplexe (aber immer noch einfache zu schreibende) Anwendung wollen wir nun einen kleinen
Taschenrechner erstellen. Wie Du schnell erkennen wirst, sind nun viele verschiedene Eigenschaften
zu verwalten: Es muß die Benutzereingabe eingelesen und das Ergebnis in ein Editierfeld geschrieben
werden.
Desweiteren benötigen wir etliche Schaltflächen für die verschiednenen Rechenoperationen und damit
auch eine Vielzahl verschiedener Events. Mein Taschenrechner sieht wie folgt aus:
Erstelle dazu zuerst Dein neues Projekt (z.B. "KSmallCalc") und öffne das "main"-Window
(wie oben beschrieben) und füge die benötigten Widgets hinzu: Das Texteingabefeld
(das sowohl für die Eingabe des Benutzers als auch für die Anzeige des Ergebnisses verwendet wird)
ist dabei vom Typ "LineEdit". In unserer Version wurde es als "edit" , die "Exit"-Schaltfläche als
"btExit", die "CLS"-Schaltfläche als "btCls", "=" als "bt0", "+" als "bt1" "-" als "bt2", "*" als
"bt3" und "/" als "bt4" bezeichnet. Es steht Dir selbstverständlich frei, andere Bezeichnungen
zu wählen, aber in der nachfolgenden Beschreibung wurden diese Namen verwendet. Das "click-Event"
der Exit-Schaltfläche kannst Du ja bereits selbst erstellen (und wenn Du willst, kannst Du
ja auch ein "Exit-Event" mit oder ohne Yes/No - MsgBox hinzufügen).
Bei den Operatoren + - * / ist das Ganze aber ein wenig komplizierter. Um das Problem zu erkennen,
wollen wir uns wieder an die benötigten Funktionen erinnern:
Es wird eine Zahl übernommen
anschließend wird auf eine Rechenoperation geklickt
und eine weitere Zahl wird eingegeben.
Zum Schluß wird das Ergebnis nach dem Drücken der "="-Schaltfläche angezeigt.
Wie leicht zu erkennen ist, kann das Ausrechnen erst nach der Eingabe von drei
Informationen erfolgen: Zwei Zahlen und die gewünschte Rechenart. Daher muß "gespeichert"
werden, auf welche Rechenoperation geklickt wurde, um später zu wissen, welche Rechenoperation
ausgeführt werden muß. Desweiteren muß die erste Zahl gespeichert werden, da diese ja
"überschrieben" wird, wenn der Benutzer die zweite Zahl in die Eingabezeile eingibt.
Um diese Werte zu sichern, werden Variablen benötigt - aber keine gewöhnlichen (lokalen)
Variablen, denn bei diesen geht - wie Du bereits weisst - deren Wert verloren, wenn
das Event, zu dem diese gehören, beendet wird. Zudem wird deren Wert später in einem
weiteren Event (event bt0_click) benötigt. Daher müssen wir regionale Variablen
verwenden. Auf diese regionalen Variablen kann von jedem Event (oder Funktion)
eines Fensters oder Unterfensters zugegriffen werden: dem Fenster, für das diese
Variablen deklariert wurden. Um eine Variable zu deklarieren, wähle die Option
"Edit -> Regional variables" aus dem Menu von KWinEdit aus. Füge nun zwei Variablen
für die erste Zahl und die Rechenart hinzu. Von mir wurden diese als "num1" und "opType"
bezeichnet. Als Initialisierungswerte wählte ich "0" und "*".
Diese Variablen können wir nun wie jede andere Variable auch verwenden, allerdings behalten
diese jedoch deren Werte bei, während wir in unserem Hauptfenster arbeiten. Wir wollen
nun den Code für die Click-Events von "+", "-", "*" und "/" erstellen.
Diese sollten den aktuellen Wert (d.h. die erste Zahl) in der Caption der Eingabe in num1
und deren eigene "ID" (+, -, *, /) in opType abspeichern. Zuletzt sollte die Caption der Eingabe
in einen leeren String ("") zurückgesetzt werden, damit der Benutzer die zweite Zahl eingeben kann.
Um auf den Wert einer "Property" (Eigenschaft) einer Variable zuzugreifen (oder diesen zu ändern),
ist ein neues Kommando nötig: property access. Die Syntax von property access ist einfach
und e-mail-ähnlich. Dies will sagen, daß die Eigenschaft, die man einlesen oder abändern möchte,
in der Form PROPERTY@WIDGET angegeben werden muß. Dabei ist PROPERTY die Eigenschaft,
die von Dir verlangt wird (z.B. Caption), und WIDGET der exakte, eindeutige Name das widgets.
Eindeutig meint, daß das Fenster in seiner gesamten Hierarchie angegeben werden muß,
wobei verschiedene Ebenen in der Hierarchie durch Punkte voneinander getrennt werden. Lautet
also das aktuelle Fenster "win", so ist der eindeutige Name von "edit" "win.edit" und der
Name von "btCls" "win.btCls". Da es aber sehr aufwendig ist, dies jedes Mal einzugeben
(vor allem, wenn man sich den Namen eines "SubButton12" im Subwindow "wdSub1" im Fenster
"mainWindow" vorstellt: "mainWindow.wdSub1.SubButton12"), besteht auch die Möglichkeit,
lediglich "." für das aktuelle Fenster ("win") und daher ".edit" für "edit" im aktuellen
Fenster einzugeben.
Aus diesem Grund lautet die "read-num1" Eingabezeile wie folgt:
num1 = Caption@.edit;
Und die Befehlszeile, um den Wert von edit auf "" zurückzusetzen:
Caption@.edit = "";
Daraus ergibt sich folgendes bt1_click-Event:
Der Code für die Schaltflächen der übrigen Rechenoperationen (-*/) ist fast derselbe; einziger
Unterschied ist die opType=...-Zeile: Es ist die entsprechende Schaltflächen-"ID" (z.B. "-" für
bt2 usw.) einzugeben.
Das einzig annähernd schwierige Event, das es noch zu editieren gilt, ist das der "="-Schaltfläche.
Denn hier soll das Programm die beiden Zahlen Addieren, Subtrahieren, Multiplizieren
oder Dividieren (genauer: Die erste, in der Variable "num1" abgespeicherte, Zahl und der Aktuelle
Wert (Caption) von "edit" ). Danach soll die Caption von edit in das Ergebnis der Rechnung
geändert werden. Das notwendige Event ist dementsprechend riiieesig: Es ist mehr als 20 Zeilen lang
und enthält vier "unterschiedliche" Code-Blöcke: Je ein "if"-Block pro Rechenoperation:
Event bt1_click()
{
If opType == "+" Then
{
Caption@.edit = num1 + Caption@.edit;
}
If opType == "-" Then
{
Caption@.edit = num1 - Caption@.edit;
}
If opType == "*" Then
{
Caption@.edit = num1 * Caption@.edit;
}
If opType == "/" Then
{
Caption@.edit = num1 / Caption@.edit;
}
}
Die Caption@.edit=...-Zeilen sind nun Operationen mit einem property access. Dabei werden
die properties genauso benutzt, wie jede andere Variable auch. Daher würde
"Caption@.edit = num1 + Caption@.edit;"
das gleiche Ergebnis liefern als "a = num1 + a;" (Diese Zeile bedeutet, daß der neue Wert von
'a' sich aus dem Wert von 'num1'+'a' zusammensetzt). Der einzige Unterschied ist, daß unsere
zweite "Variable" keine klassische Variable, sondern der aktuelle Wert der Caption-Eigenschaft von
edit ist und wir unser Ergebnis nicht in eine "unsichtbare" Variable schreiben, sondern wieder in
die Caption von Edit einfügen.
Zuallerletzt ist noch das Event der "CLS"-Schaltfläche zu schreiben. Veranlasse dieses Event,
die Caption von Edit mit "Caption@.edit = "";" wieder zurückzusetzen und ändere die Werte von
num1 und opType wieder in "0" und "+".
Installation
Wenn Dein Taschenrechner funktionert, willst Du diesen möglicherweise auch auf Deinem Rechner
fest installieren und in Dein KPanel einfügen. Vielleicht hast Du schon etwas von
makefile-hacking und ähnlichen Dingen gehört, die zur Vorbereitung der Installation eines
Projektes nötig sind. Glücklicherweise erledigen die VisKProg-Tools den Großteil der Arbeit
für Dich. Trotzdem benötigen diese einige Informationen von Dir, um einen Link ins KPanel
und um die Beschreibungsdateien des Projekts zu erzeugen. Diese Informationen werden
im ./source-Verzeichnis Ihres Projekts in der Datei "project.conf" bereitgestellt.
Öffne also diese Konfigurationsdatei in einem Texteditor (z.B. kedit) und ändere
zumindest die folgenden Einträge im Abschnitt "Project":
name: Der Name des Projekts (Name = "KSimpleCalc")
author: Dein Name
email: Deine e-mail Adresse
Speichere die Datei dann ab, wechsele in Deine Terminal-Emulation (kvt oder konsole) in
das ./source-Verzeichnis und gib "make prepare" ein. Eventuell kannst Du noch (wenn Du
willst) die "icon.xpm" und "mini-icon.xpm" - Grafiken im gleichen Verzeichnis vorher abändern.
Danach kannst Du Dein Programm installieren, so wie Du jedes andere KDE-Programm auch installierst:
Wechsele in das oberste Verzeichnis Deines Projektes und führe "./configure", "make" und
(als root) "make install" aus.
Kapitel 4: Das kleinste df (DiskFree)-Frontend der Welt
Frontends
In der UNIX-Welt sind die meisten Programme textbasiert. Da aber vor einiger Zeit immer
mehr neue Benutzer der Linux-Gemeinde beitraten, die nicht (gerne) mit shells arbeiteten,
ist es zu einer wichtigen Aufgabe geworden, graphische frontends zu diesen sehr mächtigen
textbasierten Programmen für die neuen Benutzer zu schreiben. VisKProg stellt dazu ein
widget namens "ProcCtrl" bereit, um child processes (Unterprozesse) zu kontrollieren,
z.B. ein textbasiertes Tool.
Das ProcCtrl-Widget
Dieses Widget ähnelt einem Label und es protokolliert die Textausgabe des child processes in
seiner Caption. Da sich der Benutzer normalerweise für diese Informationen weniger interessiert,
ist es standartmäßig auf unsichtbar (Visible="FALSE") gesetzt. In einigen Fällen (oder zur
Fehlersuche), ist es jedoch sinnvoll diesen Wert auf sichtbar zu stellen. Weiterhin verfügt
das ProcCtrl-Widget über vier andere Fähigkeiten:
Command: Dies beinhaltet den Namen des Programmes, das Du ausführen möchtest (z.B. "df")
Arguments: Die Kommandozeilenparameter für diese Programme (in unserem Fall benötigen wir hier keine)
Running: Ist der child-process bereits aktiv? Wenn nicht, kann er hier zur Laufzeit des Programmes
gestartet werden, indem der Wert auf "TRUE" gesetzt wird. Wenn der Wert im Editor bereits
auf "TRUE" steht, so wird dieser Prozess direkt bei der Ausführung des Programmes gestartet.
ReturnVal: Programme geben einen numerischen Wert zurück, wenn sie sich beenden. 0 steht dabei
für "finished OK" (Ohne Fehler beendet). Ein Wert größer 0 bedeutet, daß das Programm zwar startete,
aber nicht in der Lage war, die geforderten Aufgaben zu erledigen (z.B. weil eine Datei nicht
gefunden wurde o.ä.). Negative Werte (-32,-33,-34) haben eine besondere Bedeutung, die in der
Widget-Dokumentation erklärt sind. Diese Eigenschaften sind lediglich lesbar, d.h. sie
können zur Laufzeit kontrolliert werden, ihr Wert kann aber nicht abgeändert werden.
Du kannst dieses Widget nun auf verschiedene Art und Weise verwenden. Zum einen als unsichtbare
"Starthilfe" für eine andere X11 oder KDE-Anwendung, oder als einen "Geist", der im Hintergrund
laufende Kommandos überwacht (cp,rm,mv,...) oder als ein "Terminal"-label, das Dir die
Informationen anzeigt, die ein child-process in sein stdout (standard output, normal
ein Textbildschirm [Konsole oder Terminal]) ausgibt.
KMiniDF
Wir wissen zwar auch, daß es bereits etliche KDE-Frontends zum df-Tool gibt, aber dieses ist
wohl das kleinste...
Df zeigt den Status der gemounteten Partitionen an. Daher ist es nicht schwierig, dessen Ausgabe
weiterzuverarbeiten; wir müssen lediglich das ProcCtrl-Widget sichtbar machen, damit es
die gesamte Ausgabe von df anzeigt (was dann auch schon alles ist, was wir wollen). Daher
soll unser Programm "KMiniDF" aus einem kleinen Fenster mit einem ProcCtrl-Widget und zwei
Schaltflächen - einer zum "Update" der Anzeige (d.h. um df erneut auszuführen) und der anderen
zum Beenden. Ändere die Eigenschft "Visible" des ProcCtrl-Widgets in true, Command in "df",
Arguments in ""(d.h. keine Argumente) und Running zu "TRUE", da wir df direkt beim Aufruf
des Programmes ausführen möchten. Editiere nun noch das exit-Event von ProcCtrl. Dieses
Event wird dann aufgerufen, wenn sich df beendet, und wir sollten überprüfen, ob alles ohne
Fehler verlaufen ist. Ich nannte mein ProcCtrl-Widget "dfCtrl" und meine Funktion sieht wie folgt
aus:
Event dfCtrl_Exit()
{
If ReturnVal@.dfCtrl != 0 Then //!= 0 means "Not == 0"
{
MsgBox( "Error running 'df'.", 4, "Error" );
}
}
Die Update-Schaltfläche sollte df erneut starten (Running@.dfCtrl = "TRUE";), da aber die
Ausgabe eines child-prozesses an das Ende der "label"-Caption angehängt wird und wir nur
die Ausgabe des letzten df-Aufrufs wissen wollen, empfiehlt es sich, die
Caption zuerst zu leeren:
Caption@.dfCtrl = "";
Soweit die wichtigsten Informationen zu diesem Kapitel. Wie eine Exit-Schaltfläche zu
erstellen ist, hast Du ja bereits gelernt. :-)
Kapitel 5: Kcount
For- und While-Schleifen
Wir wollen nun ein kleines (in dieser Form zwar wenig nützliches) Programm schreiben, das den
User nach langweiliger PC-Arbeit etwas erheitern soll... :-)
Beim Aufruf soll zuerst eine "Start"-Schaltfläche erscheinen. Klickt der Anwender auf diese,
wird ein Countdown eingeleitet, der mit Message-Boxen zu quittieren ist. Wenn dann nach mehr
oder weniger langem "OK"-klicken schließlich der Wert "0" erreicht ist, soll der Anwender für
seine Ausdauer belohnt werden, indem ein nettes Bildchen im Hauptfenster erscheint.
Folgende Probleme sind also zu lösen:
Der Countdown
Das Einbinden eines Bildes, das erst zu einem bestimmten Zeitpunkt sichtbar werden soll
Zuerst zum Countdown:
Hierzu wollen wir das Programm dazu veranlassen, von einem bestimmten Wert bis 0 herabzuzählen.
Es gibt dazu zwei Möglichkeiten: die Verwendung von For-Schleifen bzw. von
While-Schleifen. Die Syntax lautet:
For [Wert / Variable] to [Wert / Variable] do
While ( [Variable] [Zuweisungssymbol {< > == !=}] [Variable / Wert] ) do
Unser Programm müssen wir dann von 0 bis zu einem Maximalwert hochzählen lassen. Schauen wir uns
zuerst einmal das Programm einmal mit for-Schleife und einmal mit while-Schleife zum Vergleich an:
Event StartButton_click()
{
max=5;
for i=0 to max do
{
count=max-i;
if count !=0 then
{
msgbox(count,0,"Countdown...");
}
if count ==0 then
{
msgbox("IGNITION!",0,"Countdown...");
}
}
}
|
Event StartButton1_click()
{
count=6;
while (count != 0) do
{
count=count-1;
msgbox(count,0,"Countdown...");
if count ==0 then
{
msgbox("IGNITION!",0,"Countdown...");
}
}
}
|
Die For-Schleife wird solange ausgeführt, bis von 0 zu 5 (max) heraufgezählt wurde.
Mit jedem Durchlauf der Schleife wird dabei der Wert der Variable count um 1 weniger,
da i mit jedem Durchlauf der For-Schleife i um 1 erhöht wird.
Bei der While-Schleife verhält es sich ähnlich: Diese wird solange ausgeführt, wie count
ungleich 0 ist. Während der einzelnen Durchläufe wird dabei count immer um 1 verringert.
Die if-Anweisungen in den beiden Programmen dienen nun dazu, bei den verschiedenen Werten von
count jeweils Dialogboxen mit unterschiedlichem Inhalt aufzurufen.
Versuche nun, das Programm auszuführen.
Pixmap-label
Als nächstes wollen wir nun das Bild einfügen. Dazu musst Du das Bild (das übrigens vom Format
*.xpm sein muss !!!) im Verzeichnis /source/pics deines Projektes ablegen.
Für das Darstellung eines Bildes im Fenster ist ein eigenes Label zuständig: das Pixmap-label.
Zeichne nun ein solches Label in dein Fenster und öffne das "Properties"-Menu.
In der Rubrik "Picture" kannst Du dein im Verzeichnis ./pics liegendes Bild auswählen.
H I N W E I S: Es ist auch möglich, sich mehrere Bilder in das ./pics-Verzeichnis hineinzukopieren
und dann zur Laufzeit des Programmes das anzuzeigende Bild zu wechseln. Dies geschieht einfach mit
dem Befehl Picture@.pixlabel="mein_bild2.xpm";
Da in unserem Falle das Bild zu Beginn des Programmes noch nicht sichtbar sein soll, müssen wir
noch den Wert von Visible auf "False" (d.h. nicht sichtbar) setzen.
Als nächstes ist noch der Programmcode anzupassen: In der If-Anweisung 'if count==0 then ...'
ist folgender Eintrag vorzunehmen: Visible@.pixlabel="TRUE";
Ich denke, diese Anweisung erklärt sich von selbst... :-)
Dies wären die wesentlichen Teile dieses kleinen Programmes. Alles übrige (Exit, About oder was auch
immer) ist Dir überlassen.
H I N W E I S: Wenn Du das Programm zur Probe zwischendurch ausführst, so wundere Dich nicht, wenn
Dein Bild nicht zu sehen ist. Dies ist erst nach der Installation der Fall!
weiterer geplanter Inhalt: Benutzerdefinierte Funktionen
Kapitel 6: Ein kleiner Bildbetrachter
Noch in Arbeit
geplanter Inhalt: Dateizugriff
Kapitel 7: Deine Programme
Du solltest nun in der Lage sein, Deine eigenen Programme zu schreiben. Mach dies auch
bitte!
Allerdings wirst Du wohl feststellen, daß Du immer noch nicht genug weisst, um die
Programme zu schreiben, die Du wirklich schreiben willst. Denke daher zuerst daran,
daß VisKProg immer noch alpha-Software ist und möglicherweise einige Funktionen, die Du
benötigen würdest, noch nicht vorhanden sind. Es kann allerdings sein, daß diese doch
vorhanden sind. Wirf deshalb einen Blick in die
VisKProg function documentation,
um nach Funktionen zu suchen, die Du noch nicht kennst oder lies die
widget-Dokumentation,
um mehr über Widgets zu erfahren, die Du noch nicht (vollständig) kennst.
Aber selbst dann, wenn VisKProg eine 1.0-Version erreicht haben sollte, wird es nicht
all das bieten, was mit C/C++ (und den Qt und KDE-libraries) möglich ist. Daher wirst Du
eines Tages wohl C++-KDE-Programmierung lernen wollen. Wenn dies der Fall ist, so schau
mal bei developer.kde.org (Hier finden sich
KDE-Programmierhandbücher [für Leute, die bereits C(++) kennen]) und bei
www.kdevelop.org (einer großartigen C++/KDE
Entwicklungsumgebung) vorbei.
Solltest Du ein VisKProg-Programm geschrieben haben, lass mich dies
biiiitte wissen. Wir sind an allem interessiert, und wenn Du willst, so können
wir Deine VisKProg-Programmsite veröffentlichen.
H I N W E I S zur Veröffentlichung von Programmen: Alle Programme, die zur Veröffentlichung im
Internet (d.h. zur Weitergabe) gedacht sind, müssen grundsätzlich englischsprachig sein!
Zusätzlich können Programme zwar Übersetzungsdateien mitliefern, die es ermöglichen, das
gleiche Programm auch in anderen Sprachen auszuführen, VisKProg unterstützt dies
zur Zeit jedoch nicht. Was wir aber zur Verfügung stellen können ist eine kleine (und noch
in Bearbeitung befindliche - Falls Ergänzungen notwendig sind: bitte
e-mail) wörterbuchähnliche
Tabelle mit den wichtigsten Mitteilungstexten.
Solltest Du Hilfe benötigen (das Handbuch ist ja
noch in der Bearbeitung), oder noch besser, wenn Du helfen willst, so sende eine
e-mail an de_cp@linuxstart.com. Da es noch nicht
so viele Leute gibt, die VisKProg verwenden, besteht unter Umständen auch die Möglichkeit,
spezielle Funktionen, die noch nicht vorhanden sind und die Du für Deine Programme
benötigst, hinzuzufügen. Frag nach!
Wir wünschen Dir nun viel Spaß beim Programmieren !!!
Back to the top
© 2000 by Rainer Jochem
|