Inhalt Vor

VisKProg 0.1.7

Einleitung

Vorbereitung

Kapitel 1: "Hello world!"

  • Get ready!
  • Ein Fenster erstellen
  • Übersetzen, kompilieren, ausführen, ...
  • Programmcode hinzufügen
  • Kapitel 2: "Hello world" Version 2.0

    Kapitel 3: Ein kleiner Taschenrechner

  • Das Arbeiten mit Eigenschaften
  • KSimpleCalc
  • Installation
  • Kapitel 4: Das kleinste df (DiskFree)-Frontend der Welt

  • Frontends
  • Das ProcCtrl-Widget
  • KMiniDF
  • Kapitel 5: Kcount

  • For- und While-Schleifen
  • Pixmap-labels
  • Kapitel 6: Ein kleiner Bildbetrachter

    Kapitel 7: Deine Programme

    Einleitung

    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()
    {

      Exit();
    }

    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
        Exit();
    }

    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