Erste Version für iOS

unter iOS nicht unterstützt sind AudioRecorder, VideoRecorder,
SprachEingabe, VibrationsSignal. Der BildRecorder kann nur interaktiv
aufnehmen.

source/Examples/Sprachtest/Sprachtest.py

@@ -0,0 +1,18 @@
+from velamentum.ui.dialoge.Dialog import *
+from velamentum.ui.dialoge.EingabeDialog import *
+from velamentum.sprache.Sprachausgabe import *
+
+dialog = Dialog("Sprachausgabe", "Willkommen zum Sprachtest.")
+dialog.zeige()
+
+eDialog = EingabeDialog("Sprachausgabe", "Bitte geben Sie einen Text ein.")
+eDialog.zeige()
+
+sprachausgabe = Sprachausgabe(eDialog.nenneErgebnis())
+sprachausgabe.sprechen()
+
+while sprachausgabe.sprichtNoch():
+    pass
+
+dialog.setzeNachricht("Ich habe gesprochen!")
+dialog.zeige()

source/Examples/SteinScherePapier/SteinScherePapier.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+from velamentum.ui.dialoge.Dialog import *
+from velamentum.ui.dialoge.EntscheidungsDialog import *
+from velamentum.werkzeuge.Zufallsgenerator import *
+
+# Dialog vorbereiten und Begrüßung anzeigen
+dialog = Dialog("Stein, Papier, Schere", "Willkommen zum Spiel!")
+dialog.zeige()
+
+# EntscheidungDialog vorbereiten
+eDialog = EntscheidungsDialog("Stein, Papier, Schere", "Bitte wählen Sie" \
+    "Ihren Gegenstand.")
+
+eDialog.setzeText1("🌑 Stein")
+eDialog.setzeText2("✂️ Schere")
+eDialog.setzeText3("📃 Papier")
+eDialog.setzeDreiTasten(True)
+
+# Entscheidung einfordern
+while eDialog.nenneErgebnis() == 0:
+    eDialog.zeige()
+
+# Zufallsgenerator vorbereiten
+zufall = Zufallsgenerator(1,3)
+
+# Sieger ermitteln
+if zufall.nenneErgebnis() == 1:
+    dialog.zeigeNachricht("Ich habe 'Stein' gewählt.")
+    if eDialog.nenneErgebnis() == 1:
+        dialog.zeigeNachricht("Unentschieden!")
+    elif eDialog.nenneErgebnis() == 2:
+        dialog.zeigeNachricht("Ich habe gewonnen!")
+    else:
+        dialog.zeigeNachricht("Sie haben gewonnen!")
+elif zufall.nenneErgebnis() == 2:
+    dialog.zeigeNachricht("Ich habe 'Schere' gewählt.")
+    if eDialog.nenneErgebnis() == 1:
+        dialog.zeigeNachricht("Sie haben gewonnen!")
+    elif eDialog.nenneErgebnis() == 2:
+        dialog.zeigeNachricht("Unentschieden!")
+    else:
+        dialog.zeigeNachricht("Ich habe gewonnen!")
+else:
+    dialog.zeigeNachricht("Ich habe 'Papier' gewählt.")
+    if eDialog.nenneErgebnis() == 1:
+        dialog.zeigeNachricht("Ich habe gewonnen!")
+    elif eDialog.nenneErgebnis() == 2:
+        dialog.zeigeNachricht("Sie haben gewonnen!")
+    else:
+        dialog.zeigeNachricht("Unentschieden!")

source/Examples/SuS/Schlauheitstest/Schlauheitstest.py

@@ -0,0 +1,80 @@
+from velamentum.alle import*
+punkte=0
+d=Dialog("Schlauheits-Test","Teste, wie schlau du bist!")
+d.zeige()
+ed=EntscheidungsDialog("Laender-Frage","Wie viele Laender gehoeren zu Der EU?")
+ed.text1="28"
+ed.text2="17"
+ed.zweiTasten=True
+ed.zeige()
+if(ed.ergebnis==1):
+    d.nachricht="Richtig! Es gehoeren 28 Laender zu der EU."; punkte+=2
+elif(ed.ergebnis==2): 
+    d.nachricht="Leider Falsch!" 
+d.zeige()
+ed=EntscheidungsDialog("Personen-Frage","Wieviele Leute lebten 2012 in Deutschland?")
+ed.text1="40000000"
+ed.text2="80000000"
+ed.text3="81000000"
+ed.dreiTasten=True
+ed.zeige()
+if(ed.ergebnis==1):
+    d.nachricht="Leider Falsch!"
+elif(ed.ergebnis==2):
+    d.nachricht="Fast Richtig!"
+elif(ed.ergebnis==3):
+    d.nachricht="Richtig! 2012 lebten 81000000 Menschen in Deutschland."
+d.zeige()
+ed=EntscheidungsDialog("Einwohner-Frage","Welche Stadt hat Die meisten Einwohner?")
+ed.text1="Peking"
+ed.text2="New York"
+ed.text3="Mexico-City"
+ed.dreiTasten=True
+ed.zeige()
+if (ed.ergebnis==1):
+    d.nachricht="Leider Falsch, Peking hat 15800000 Einwohner Und damit 4.300.000 Einwohner weniger, Als Die Stadt Mit Den meisten Einwohnern."
+elif (ed.ergebnis==2):
+    d.nachricht="Leider Falsch, New York hat 8200000 Einwohner Und damit Ca. 11.800.000 Einwohner weniger, Als Die Stadt Mit Den meisten Einwohnern."
+elif (ed.ergebnis==3):
+    d.nachricht="Richtig, Mexico-City hat 20100000 Einwohner Und Ist damit Die Stadt Mit Den meisten Einwohnern Der Welt."; punkte+=3
+d.zeige()
+ed=EntscheidungsDialog("Film-Frage","Welcher Film hat Das meiste geld eingebracht?")
+ed.text1="Avatar"
+ed.text2="Skyfall"
+ed.text3="Iron Man 3"
+ed.dreiTasten=True
+ed.zeige()
+if (ed.ergebnis==1):
+    d.nachricht="Richtig, Der Film Avatar hat 2800000000 Dollar eingespielt Und Ist damit Auf Platz 1!"; punkte+=3
+elif (ed.ergebnis==2):
+    d.nachricht="Leider Falsch, Der Film Skyfall hat 1100000000 Dollar eingespielt Und liegt damit auf Platz 9."
+elif (ed.ergebnis==3):
+    d.nachricht="Leider Falsch, Der Film Iron Man 3 hat 1200000000 Dollar eingespielt Und liegt damit Auf Platz 6."
+d.zeige()
+ed=EntscheidungsDialog("Koerperteil-Frage","Wie viele Knochen hat der menschliche Koerper Im Durchschnitt?")
+ed.text1="150"
+ed.text2="206"
+ed.text4="403"
+ed.dreiTasten=True
+ed.zeige()
+if (ed.ergebnis==1):
+    d.nachricht="Leider Falsch, er hat mehr, Als Nur 150 Knochen."
+elif (ed.ergebnis==2):
+    d.nachricht="Richtig, allerdings Ist dies Nur Der Durchschnitt. Kleine Kinder Haben beispielsweise Noch mehr Knochen, Als erwachsene Menschen, Weil Die Knochen Mit dem Alter zusammenwachsen!"; punkte+=3
+elif (ed.ergebnis==3):
+    d.nachricht="Ganz Falsch"
+d.zeige()
+ed=EntscheidungsDialog("Fertig!","Willst du wissen, Wie viele Punkte Du erreicht hast")
+ed.text1="Ja"
+ed.text2="Nein"
+ed.zweiTasten=True
+ed.zeige()
+if (ed.ergebnis==1):
+    d.nachricht="Du hast %d Punkte erreicht!" % (punkte)
+elif (ed.ergebnis==2):
+    d.nachricht="Danke fuers spielen!"
+if(ed.ergebnis == 1 and punkte>=8):
+    d.nachricht="Du hast %d Punkte erreicht Und bist damit schlau!" % (punkte)
+elif(ed.ergebnis == 1 and punkte<=8):
+    d.nachricht="Du hast %d Punkte erreicht Und bist damit dumm!" % (punkte)
+d.zeige()

source/Examples/Zahlenraten/Zahlenraten.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+from velamentum.alle import *
+
+# Zufallsgenerator vorbereiten
+zufall = Zufallsgenerator(1,1000)
+
+# Dialog vorbereiten und Begrüßung anzeigen
+dialog = Dialog("Zahlenraten", "Willkommen zum Spiel!")
+dialog.zeige()
+
+dialog.zeigeNachricht("Ich habe eine Zahl zwischen 1 und 1000 gewählt." \
+    "Raten Sie welche es ist!")
+
+# EingabeDialog vorbereiten
+eDialog = EingabeDialog("Zahlenraten", "Bitte geben Sie eine Zahl zwischen 1 " \
+    "und 1000 ein:", True)
+
+# Zähler für die Versuche initialisieren
+versuche = 0
+
+# Entscheidung einfordern
+while eDialog.nenneErgebnis() != zufall.nenneErgebnis():
+    # Anzahl der Versuche um eins erhöhen
+    versuche += 1
+    
+    # EingabeDialog anzeigen
+    eDialog.zeige()
+    
+    # Eingabe überprüfen
+    if eDialog.nenneErgebnis() > zufall.nenneErgebnis():
+        dialog.zeigeNachricht("Ihre Zahl war zu groß!")
+    elif eDialog.nenneErgebnis() < zufall.nenneErgebnis():
+        dialog.zeigeNachricht("Ihre Zahl war zu klein!")
+    
+dialog.zeigeNachricht("Herzlichen Glückwunsch! Sie haben die Zahl nach {0} " \
+    "Versuchen erraten.".format(versuche))

source/iOS/alle.py

@@ -0,0 +1,22 @@
+from velamentum.dateien.DateiSystemElement import DateiSystemElement
+from velamentum.dateien.Datei import Datei
+from velamentum.dateien.Verzeichnis import Verzeichnis
+from velamentum.multimedia.Recorder import Recorder
+from velamentum.multimedia.AudioRecorder import AudioRecorder
+from velamentum.multimedia.BildRecorder import BildRecorder
+from velamentum.multimedia.VideoRecorder import VideoRecorder
+from velamentum.multimedia.Player import Player
+from velamentum.multimedia.AudioPlayer import AudioPlayer
+from velamentum.signale.Signal import Signal
+from velamentum.signale.AudioSignal import AudioSignal
+from velamentum.signale.TextSignal import TextSignal
+from velamentum.signale.VibrationsSignal import VibrationsSignal
+from velamentum.sprache.Spracheingabe import Spracheingabe
+from velamentum.sprache.Sprachausgabe import Sprachausgabe
+from velamentum.ui.dialoge.Dialog import Dialog
+from velamentum.ui.dialoge.EingabeDialog import EingabeDialog
+from velamentum.ui.dialoge.EntscheidungsDialog import EntscheidungsDialog
+from velamentum.ui.dialoge.PasswortDialog import PasswortDialog
+from velamentum.werkzeuge.System import System
+from velamentum.werkzeuge.Zufallsgenerator import Zufallsgenerator
+from velamentum.werkzeuge.Zwischenablage import Zwischenablage

source/iOS/dateien/Datei.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+from velamentum.dateien.DateiSystemElement import DateiSystemElement
+
+class Datei(DateiSystemElement):
+    """Die Klasse Datei dient dem Umgang mit Dateien.   
+    
+    Attribute:
+        --- von 'DateiSystemElement' geerbte ---
+        groesse (Zahl): Die Größe der Datei in Byte.
+        inhalt (Zeichenkette): Der Inhalt der Datei.
+    """
+    
+    def __init__(self, pPfad, pSofortEinlesen=False):
+        """Konstruktor. Initialisiert die Datei.
+        
+        Parameter: 
+            pPfad (Zeichenkette): Der Pfad der Datei.
+            [optional] pSofortEinlesen: Gibt an, ob die Datei direkt bei der
+                Initialisierung eingelesen werden soll. [Standardwert: False]
+        """
+        DateiSystemElement.__init__(self, pPfad)
+        if(pSofortEinlesen):
+            self.einlesen()
+    
+    def nenneGroesse(self):
+        """Anfrage. Gibt die Größe der Datei in Byte zurück.
+        
+        Parameter:
+            --- keine ---
+            
+        Rückgabe (Zahl): Die Größe der Datei in Byte.
+        """
+        tSize = 0
+        if self.istVorhanden():
+            try:
+                tSize = os.path.getsize(self.pfad)
+            except:
+                print("Fehler. Auf '%s' kann nicht zugegriffen werden."
+                    % self._pfad)
+        
+    def einlesen(self):
+        """Auftrag. Liest die Datei in das Attribut 'inhalt' ein.
+        
+        Parameter:
+            --- keine ---
+        """
+        if self.istVorhanden():
+            try:
+                tDatei = open(self._pfad, "r")
+                self.inhalt = tDatei.read()
+                tDatei.close()
+            except:
+                print("Fehler. Einlesen von '%s' nicht möglich." % self._pfad)
+        else:
+            self.inhalt = ""
+            
+    def speichern(self):
+        """Auftrag. Schreibt den Wert des Attributs 'inhalt' in die Datei.
+        
+        Parameter:
+            --- keine ---
+        """
+        try:
+            tDatei = open(self._pfad, "w")
+            tDatei.write(self.inhalt)
+            tDatei.close()
+        except:
+            print("Fehler. Speichern von '%s' nicht möglich." % self._pfad)
+            
+    # Attribute (verdeckte Getter und Setter)
+    groesse = property(nenneGroesse, doc="Die Größe der Datei in Byte.")

source/iOS/dateien/DateiSystemElement.py

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+# Modul zur Erkennung des MIME-Types des Elements. 
+import mimetypes, shutil, os.path
+
+class DateiSystemElement(object):
+    """Die Klasse DateiSystemElement stellt die Basisklasse für Elemente
+    im Dateisystem (z.B. Dateien und Verzeichnisse) dar.   
+    
+    Anmerkungen: 
+        - Eigentlich sollte ein DateiSystemElement seinen eigenen Pfad nicht
+          kennen. Auch das Umbenennen und weitere Verwaltungsfunktionen gehören
+          eher zum übergeordneten Dateisystem. Aus praktikabilitätsgründen
+          wurde allerdings diese Implementierung gewählt.
+        - Für die Erkennung des MIME-Types wird derzeit lediglich die
+          Erweiterung des Elements berücksichtigt.
+    
+    Attribute:
+        name (Zeichenkette): Der Name des Elements im Dateisystem.
+        pfad (Zeichenkette): Der Pfad des Elements im Dateisystem.
+        typ (Zeichenkette): Gibt den MIME-Type des Elements an.
+        verzeichnis (Zeichenkette): Der Pfad des übergeordneten Verzeichnisses
+            der Datei.
+    """
+    
+    def __init__(self, pPfad):
+        """Konstruktor. Initialisiert das DateiSystemElement.
+        
+        Parameter: 
+            pPfad (Zeichenkette): Der Pfad des DateiSystemElements.
+        """
+        # Slash am Ende entfernen
+        if pPfad.endswith('/'):
+            pPfad = pPfad[:-1]
+            
+        self._pfad = pPfad
+        self._erkenneTyp()
+        
+    def _erkenneTyp(self):
+        """Hilfsmethode. Erkennt den Typ des DateiSystemElements und speichert.
+        diesen im Attribut 'typ'.
+        """
+        if os.path.isfile(self._pfad):
+            # Erkennung des MIME-Types. Es wird lediglich die Erweiterung
+            # der Datei geprüft.
+            self.typ = mimetypes.guess_type(self._pfad, False)
+        elif os.path.isdir(self._pfad):
+            self.typ = "inode/directory"
+        elif os.path.islink(self._pfad):
+            self.typ = "inode/symlink"
+        elif os.path.ismount(self._pfad):
+            self.typ = "inode/mount-point"
+        else:
+            self.typ = "application/octet-stream"
+    
+    def istVorhanden(self):
+        """Anfrage. Prüft, ob das Element im Dateisystem bereits existiert.        
+        
+        Parameter:
+            --- keine ---
+        
+        Rückgabe (Wahrheitswert): True falls das Element im Dateisystem bereits
+            existiert, sonst False. 
+        """
+        return os.path.exists(self._pfad)
+    
+    def nennePfad(self):
+        """Anfrage. Gibt den Pfad des Elements im Dateisystem zurück."""
+        return self._pfad
+        
+    def nenneVerzeichnis(self):
+        """Anfrage. Gibt das übergeordnete Verzeichnis des Elements zurück."""
+        return os.path.dirname(self._pfad)
+    
+    def nenneName(self):
+        """Anfrage. Gibt den Namen des Elements im Dateisystem zurück."""
+        return os.path.basename(self._pfad)
+        
+    def nenneTyp(self):
+        """Anfrage. Gibt den Typ des Elements zurück (als MIME-Type)."""
+        return self.typ
+    
+    def verschieben(pPfad):
+        """Auftrag. Hängt das Element im Dateisystem um. 
+        
+        Parameter:
+            pPfad (Zeichenkette): Gibt den neuen Pfad im Dateisystem an.
+        """
+        # Verschieben, falls Element bereits existiert.
+        if os.path.exists(pPfad):
+            try:
+                shutil.move(self._pfad, pPfad)
+                self._pfad = pPfad
+            except:
+                print("Fehler. Verschieben von '%s' nicht möglich." % self._pfad)
+         
+    # Attribute (verdeckte Getter und Setter)
+    pfad = property(nennePfad, verschieben, doc="Der Pfad des " \
+        "DateiSystemElements im Dateisystem.")
+    name = property(nenneName, doc="Der Name des DateiSystemElements im" \
+        "Dateisystem.")
+    verzeichnis = property(nenneVerzeichnis, doc="Der Pfad des übergeordneten" \
+        " Verzeichnisses des DateiSystemElements im Dateisystem.")
+    
+    

source/iOS/dateien/Verzeichnis.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+from velamentum.dateien.DateiSystemElement import DateiSystemElement
+import os
+
+class Verzeichnis(DateiSystemElement):
+    """Die Klasse Verzeichnis dient dem Umgang mit Verzeichnissen.   
+    
+    Attribute:
+        --- von 'DateiSystemElement' geerbte ---
+    """
+    
+    def __init__(self, pPfad):
+        """Konstruktor. Initialisiert das Verzeichnis.
+        
+        Parameter: 
+            pPfad (Zeichenkette): Der Pfad des Verzeichnisses.
+        """
+        DateiSystemElement.__init__(self, pPfad)
+        
+    def nenneKinder(self):
+        """Anfrage. Gibt eine Liste der Kinder des Verzeichnisses zurück."""
+        tListe = []
+        
+        try:
+            tListe = os.listdir(self._pfad)
+        except:
+            print("Fehler. Einlesen von '%s' nicht möglich." % self._pfad)
+        
+        return tListe

source/iOS/multimedia/AudioPlayer.py

@@ -0,0 +1,166 @@
+# -*- coding: utf-8 -*-
+import time
+import random
+import velamentum.dateien.Datei
+from velamentum.multimedia.Player import Player
+import sound
+
+class AudioPlayer(Player):
+    """Die Klasse Player dient der Wiedergabe von Multimediadaten aus einer
+    Datei.
+    
+    Attribute:
+        --- von 'Player' geerbte ---
+        datei (Datei): Die Datei, deren Inhalt wiedergegeben werden soll.
+        dauer (Zahl): Gesamtdauer der Datei in Millisekunden.
+        position (Zahl): Die aktuelle Position der Wiedergabe in Millisekunden.
+        wiederholen (Wahrheitswert): Gibt an, ob die Wiedergabe am Ende von
+            vorne beginnen soll.
+    """
+
+    def __init__(self, pDatei, pSofortWiedergeben=False):
+        """Konstruktor. Initialisiert den Player.
+        
+        Parameter:
+            pDatei (Datei): Datei, die wiedergegeben werden soll.
+            [optional] pSofortWiedergeben (Wahrheitswert): Soll die Datei direkt
+                nach der Initialisierung wiedergegeben werden?
+        """
+        self.datei = pDatei
+        # Eindeutige ID festlegen zur Verwaltung verschiedener gleichzeitig
+        # wiederzugebender Streams.
+        self._id = "%s%04d" % (pDatei.nenneName(), random.randint(0,8191))
+
+        if self.datei.istVorhanden():
+            self.player = sound.Player(self.datei.nennePfad())
+        else:
+            print("Fehler. Datei %s nicht gefunden." % pDatei.nennePfad())
+        
+    def __del__(self):
+        """Destruktor. Stellt sicher, dass die Wiedergabe beim Löschen des
+        Objekts beendet wird.
+        
+        Parameter:
+            --- keine ---
+        """
+        pass
+
+    def nenneDauer(self):
+        """Anfrage. Gibt die Gesamtdauer der Datei zurück.
+        
+        Parameter:
+            --- keine ---
+            
+        Rückgabe (Zahl): Gesamtdauer der Datei in Millisekunden.
+        """
+        return self.player.duration * 1000
+    
+    def nennePosition(self):
+        """Anfrage. Gibt die aktuelle Position der Wiedergabe zurück.
+        
+        Parameter:
+            --- keine ---
+            
+        Rückgabe (Zahl): Aktuelle Position der Wiedergabe in Millisekunden.
+        """
+        return self.player.current_time * 1000
+    
+    def setzePosition(self, pPosition):
+        """Auftrag. Legt die aktuelle Position der Wiedergabe fest.
+        
+        Parameter:
+            pPosition (Zahl): Neue Position in Millisekunden.
+        """
+        # Position auf gültigen Bereich (0 - dauer) beschränken.
+        if pPosition > self.dauer:
+            pPosition = self.dauer
+        elif pPosition < 0:
+            pPosition = 0
+        
+        self.player.current_time = pPosition/1000
+
+    
+    def nenneDatei(self):
+        """Anfrage. Gibt die Datei zurück, die wiedergegeben werden soll.
+        
+        Parameter:
+            --- keine ---
+            
+        Rückgabe (Datei): Datei, die wiedergegeben werden soll.
+        """
+        return self.datei
+
+    def setzeDatei(self, pDatei):
+        """Auftrag. Legt die Datei fest, die wiedergegeben werden soll.
+        
+        Parameter:
+            pDatei (Datei): Datei, die wiedergegeben werden soll.
+        """
+
+        if pDatei.istVorhanden():
+            self.player = sound.Player(pDatei.nennePfad())
+            Player.setzeDatei(self, pDatei)
+        else:
+            print("Fehler. Datei %s nicht gefunden." % pDatei.nennePfad())
+        
+    def nenneWiederholen(self):
+        """Anfrage. Gibt zurück, ob die Wiedergabe am Ende wieder von vorne
+        beginnen soll.
+
+        Parameter:
+            --- keine ---
+            
+        Rückgabe (Wahrheitswert): Soll die Datei wiederholt 
+            wiedergegeben werden? 
+        """
+        return True if self.player.number_of_loops == -1 else False
+        
+    def setzeWiederholen(self, pWiederholen):
+        """Auftrag. Legt fest, ob die Wiedergabe am Ende wieder von vorne
+        beginnen soll.
+
+        Parameter:
+            pWiederholen (Wahrheitswert): Soll die Datei wiederholt 
+                wiedergegeben werden? 
+        """
+        if pWiederholen:
+            self.player.number_of_loops = -1
+        else:
+            self.player.number_of_loops = 0
+
+    def wiedergeben(self):
+        """Auftrag. Startet die Wiedergabe der Multimediadaten. 
+        
+        Parameter 
+            --- keine ---
+        """
+        self.player.play()
+        
+    def pausieren(self):
+        """Auftrag. Pausiert die Wiedergabe der Multimediadaten. Die Wiedergabe
+        kann mit 'wiedergeben' fortgesetzt werden.
+        
+        Parameter 
+            --- keine ---
+        """
+        self.player.pause()
+    
+    def stoppen(self):
+        """Auftrag. Stoppt die Wiedergabe der Multimediadaten. (Wie 'pausieren',
+        Wiedergabe kann jedoch nicht fortgesetzt werden, sondern beginnt dann
+        von vorne.
+        
+        Parameter 
+            --- keine ---
+        """
+        self.player.stop()
+    
+    # Attribute (verdeckte Getter und Setter)
+    datei = property(nenneDatei, setzeDatei, doc="Die Datei, deren Inhalt " \
+        "wiedergegeben werden soll.")
+    dauer = property(nenneDauer, doc="Die Gesamtdauer der Datei in Millisekunden.")
+    position = property(nennePosition, setzePosition, doc = "Die aktuelle "\
+        "Position der Wiedergabe.")
+    wiederholen = property(nenneWiederholen, setzeWiederholen, doc="Gibt an, "\
+        "ob die Wiedergabe am Ende wieder von vorne beginnen soll.")
+

source/iOS/multimedia/AudioRecorder.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+import velamentum.dateien.Datei
+from velamentum.multimedia.Recorder import Recorder
+import dialogs
+
+class AudioRecorder(Recorder):
+    """Die Klasse AudioRecorder dient der Aufnahme von Audiodaten in eine Datei.
+    
+    Attribute:
+        --- von 'Recorder' geerbte ---
+    """
+
+    def __init__(self, pDatei=velamentum.dateien.Datei.Datei("~/aufnahme.m4a")):
+        """Konstruktor. Initialisiert den AudioRecorder.
+        
+        Parameter:
+            [optional] pDatei (Datei): Datei, in der die Aufnahme gespeichert
+                werden soll [Standardwert: Datei mit Pfad '~/aufnahme.m4a'].
+        """
+        Recorder.__init__(self, pDatei)
+        dialogs.alert('Fehler', 'AudioRecorder auf iOS nicht implementiert.')

source/iOS/multimedia/BildRecorder.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+import velamentum.dateien.Datei
+from velamentum.multimedia.Recorder import Recorder
+import photos
+
+class BildRecorder(Recorder):
+    """Die Klasse BildRecorder dient der Aufnahme von Bilddaten in eine Datei.
+    
+    Attribute:
+        --- von 'Recorder' geerbte ---
+    """
+
+    def __init__(self, pDatei=velamentum.dateien.Datei.Datei("/sdcard/aufnahme.jpg")):
+        """Konstruktor. Initialisiert den BildRecorder.
+        
+        Parameter:
+            [optional] pDatei (Datei): Datei, in der die Aufnahme gespeichert
+                werden soll [Standardwert: Datei mit Pfad '/scard/aufnahme.jpg'].
+        """
+        Recorder.__init__(self, pDatei)
+
+    def aufnehmen(self):
+        """Auftrag. Macht ein Foto und speichert es in der angegebenen Datei. 
+        
+        HINWEIS: Die angegebene Datei wird überschrieben.
+        
+        Parameter 
+            --- keine ---
+        """
+        self.aufnehmenInteraktiv()
+    
+    def stoppen(self):
+        """Auftrag. Dummy. Für Fotos nutzlos.
+        
+        Parameter 
+            --- keine ---
+        """
+        pass
+        
+    def aufnehmenInteraktiv(self):
+        """Auftrag. Startet eine interaktive Aufnahme. Der Benutzer erhält die
+        Möglichkeit die Aufnahme interaktiv zu starten und zu stoppen. Dazu wird
+        auf die Standard-Kamera-App zurückgegriffen.
+        
+        HINWEIS: Die angegebene Datei wird überschrieben.
+        
+        Parameter:
+            --- keine ---
+        """
+        imgTmp = photos.capture_image()
+        imgTmp.save(self.datei.nennePfad(), quality=90)
+

source/iOS/multimedia/Player.py

@@ -0,0 +1,132 @@
+# -*- coding: utf-8 -*-
+import time
+import velamentum.dateien.Datei
+
+class Player(object):
+    """Die Klasse Player dient der Wiedergabe von Multimediadaten aus einer
+    Datei.
+    
+    Attribute:
+        datei (Datei): Die Datei, deren Inhalt wiedergegeben werden soll.
+        dauer (Zahl): Gesamtdauer der Datei in Millisekunden.
+        position (Zahl): Die aktuelle Position der Wiedergabe in Millisekunden.
+        wiederholen (Wahrheitswert): Gibt an, ob die Wiedergabe am Ende von
+            vorne beginnen soll.
+    """
+
+    def __init__(self, pDatei):
+        """Konstruktor. Initialisiert den Player.
+        
+        Parameter:
+            pDatei (Datei): Datei, die wiedergegeben werden soll.
+        """
+        self.datei = pDatei
+        # Eindeutige ID festlegen zur Verwaltung verschiedener gleichzeitig
+        # wiederzugebender Streams.
+        self._id = "%s%04d" % (pDatei.nenneName(), randint(0,4095))
+    
+    def nenneDatei(self):
+        """Anfrage. Gibt die Datei zurück, die wiedergegeben werden soll.
+        
+        Parameter:
+            --- keine ---
+            
+        Rückgabe (Datei): Datei, die wiedergegeben werden soll.
+        """
+        return self.datei
+    
+    def setzeDatei(self):
+        """Anfrage. Gibt die Datei zurück, die wiedergegeben werden soll.
+        
+        Parameter:
+            --- keine ---
+            
+        Rückgabe (Datei): Datei, die wiedergegeben werden soll.
+        """
+        return self.datei
+        
+    def nenneWiederholen(self):
+        """Anfrage. Gibt zurück, ob die Wiedergabe am Ende wieder von vorne
+        beginnen soll.
+
+        Parameter:
+            --- keine ---
+            
+        Rückgabe (Wahrheitswert): Soll die Datei wiederholt 
+            wiedergegeben werden? 
+        """
+        return False
+        
+    def setzeWiederholen(self, pWiederholen):
+        """Auftrag. Legt fest, ob die Wiedergabe am Ende wieder von vorne
+        beginnen soll.
+
+        Parameter:
+            pWiederholen (Wahrheitswert): Soll die Datei wiederholt 
+                wiedergegeben werden? 
+        """
+        pass
+    
+    def nenneDauer(self):
+        """Anfrage. Gibt die Gesamtdauer der Datei zurück.
+        
+        Parameter:
+            --- keine ---
+            
+        Rückgabe (Zahl): Gesamtdauer der Datei in Millisekunden.
+        """
+        return 0
+    
+    def nennePosition(self):
+        """Anfrage. Gibt die aktuelle Position der Wiedergabe zurück.
+        
+        Parameter:
+            --- keine ---
+            
+        Rückgabe (Zahl): Gesamtdauer der Datei in Millisekunden.
+        """
+        return 0
+    
+    def setzePosition(self, pPosition):
+        """Auftrag. Legt die aktuelle Position der Wiedergabe fest.
+        
+        Parameter:
+            pPosition (Zahl): Neue Position in Millisekunden.
+        """
+        pass
+
+    def wiedergeben(self):
+        """Auftrag. Startet die Wiedergabe der Multimediadaten. 
+        
+        Parameter 
+            --- keine ---
+        """
+        pass
+        
+    def pausieren(self):
+        """Auftrag. Pausiert die Wiedergabe der Multimediadaten. Die Wiedergabe
+        kann mit 'wiedergeben' fortgesetzt werden.
+        
+        Parameter 
+            --- keine ---
+        """
+        pass
+    
+    def stoppen(self):
+        """Auftrag. Stoppt die Wiedergabe der Multimediadaten.
+        
+        Parameter 
+            --- keine ---
+        """
+        pass
+    
+    # Attribute (verdeckte Getter und Setter)
+    datei = property(nenneDatei, setzeDatei, doc="Die Datei, deren Inhalt " \
+        "wiedergegeben werden soll.")
+    dauer = property(nenneDauer, doc="Die Gesamtdauer der Datei in Millisekunden.")
+    position = property(nennePosition, setzePosition, doc = "Die aktuelle "\
+        "Position der Wiedergabe.")
+    wiederholen = property(nenneWiederholen, setzeWiederholen, doc="Gibt an, "\
+        "ob die Wiedergabe am Ende wieder von vorne beginnen soll.")
+
+

source/iOS/multimedia/Recorder.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+import time
+import velamentum.dateien.Datei
+
+class Recorder(object):
+    """Die Klasse Recorder dient der Aufnahme von Multimediadaten in eine Datei.
+    
+    Attribute:
+        aufnahmeLaeuft (Wahrheitswert): Gibt an, ob gerade eine Aufnahme läuft.
+        datei (Datei): Die Datei, in der die Aufnahme gespeichert werden soll.
+    """
+
+    def __init__(self, pDatei=velamentum.dateien.Datei.Datei("~/aufnahme")):
+        """Konstruktor. Initialisiert den Recorder.
+        
+        Parameter:
+            [optional] datei (Datei): Datei, in der die Aufnahme gespeichert
+                werden soll [Standardwert: Datei mit Pfad '/scard/aufnahme'].
+        """
+        self.aufnahmeLaeuft = False
+        self.datei = pDatei
+    
+    def nimmtAuf(self):
+        """Anfrage. Gibt an, ob gerade eine Aufgabe läuft.
+        
+        Parameter:
+            --- keine ---
+            
+        Rückgabe (Wahrheitswert): True falls eine Aufnahme läuft, False sonst.
+        """
+        return self.aufnahmeLaeuft
+    
+    def nenneDatei(self):
+        """Anfrage. Gibt die Datei zurück, in der die Aufnahme gespeichert
+            werden soll.
+        
+        Parameter 
+            --- keine ---
+            
+        Rückgabe (Datei): Datei, in der die Aufnahme gespeichert werden soll.
+        """
+        return self.datei
+        
+    def setzeDatei(self, pDatei):
+        """Auftrag. Legt die Datei fest, in der die Aufnahme gespeichert
+        werden soll.
+        
+        Parameter 
+            pDatei (Datei): Datei, in der die Aufnahme gespeichert werden soll.
+        """
+        self.datei = pDatei
+
+    def aufnehmen(self):
+        """Auftrag. Startet die Aufnahme der Multimediadaten. 
+        
+        HINWEIS: Die angegebene Datei wird überschrieben.
+        
+        Parameter 
+            --- keine ---
+        """
+        self.aufnahmeLaeuft = True
+    
+    def stoppen(self):
+        """Auftrag. Stoppt die Aufnahme der Multimediadaten.
+        
+        Parameter 
+            --- keine ---
+        """
+        self.aufnahmeLaeuft = False
+    
+    def aufnehmenAuto(self, pDauer):
+        """Auftrag. Startet eine Aufnahme mit der in 'pDauer' angegebenen Dauer
+        und beendet die Aufnahme danach automatisch. 
+        
+        HINWEIS: Die angegebene Datei wird überschrieben.
+        
+        Parameter 
+            pDauer (Zahl): Dauer der Aufnahme.
+        """
+        self.aufnehmen()
+        time.sleep(pDauer)
+        self.stoppen()
+        
+    def aufnehmenInteraktiv(self):
+        """Auftrag. Startet eine interaktive Aufnahme. Der Benutzer erhält die
+        Möglichkeit die Aufnahme interaktiv zu starten und zu stoppen. Dazu wird
+        in der Regel auf die jeweilige Recorder-Applikation zurückgegriffen.
+        
+        HINWEIS: Die angegebene Datei wird überschrieben.
+        
+        Parameter:
+            --- keine ---
+        """
+        pass
+

source/iOS/multimedia/VideoRecorder.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+import velamentum.dateien.Datei
+from velamentum.multimedia.Recorder import Recorder
+import dialogs
+
+class VideoRecorder(Recorder):
+    """Die Klasse VideoRecorder dient der Aufnahme von Videodaten in eine Datei.
+    
+    Attribute:
+        --- von 'Recorder' geerbte ---
+    """
+
+    def __init__(self, pDatei=velamentum.dateien.Datei.Datei("~/aufnahme.mp4")):
+        """Konstruktor. Initialisiert den VideoRecorder.
+        
+        Parameter:
+            [optional] pDatei (Datei): Datei, in der die Aufnahme gespeichert
+                werden soll [Standardwert: Datei mit Pfad '/scard/aufnahme.m4a'].
+        """
+        Recorder.__init__(self, pDatei)
+        dialogs.alert('Fehler', 'VideoRecorder auf iOS nicht implementiert.')

source/iOS/signale/AudioSignal.py

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+from velamentum.signale.Signal import Signal
+from velamentum.multimedia.AudioPlayer import AudioPlayer
+from velamentum.dateien.Datei import Datei
+import os.path
+
+class AudioSignal(Signal):
+    """Die Klasse AudioSignal dient der Übermittlung von Audiosignalen 
+    an den Benutzer.
+    
+    Attribute:
+        datei (Datei): Audiodatei, die für das Signal verwendet werden soll.
+    """
+
+    def __init__(self, pDatei=None):
+        """Konstruktor. Initialisiert das AudioSignal.
+        
+        Parameter:
+            [optional] pDatei (Zeichenkette): Audiodatei, die für das Signal
+                verwendet werden soll. [Standardwert: None]
+        """
+        Signal.__init__(self)
+        self.setzeDatei(pDatei)
+        self.__audioPlayer = AudioPlayer(self.nenneDatei())
+
+    def nenneDatei(self):
+        """Anfrage. Gibt die Audiodatei des Signals zurück.
+        
+        Parameter:
+            --- keine ---
+            
+        Rückgabe (Zeichenkette): Audiodatei des Signals.
+        """
+        return self.__datei
+        
+    def setzeDatei(self, pDatei):
+        """Auftrag. Ändert die Audiodatei des Signals.
+        
+        Parameter:
+            pDatei (Zeichenkette): Audiodatei des Signals.        
+        """ 
+        # Falls keine Datei angegeben wurde, verwende Standarddatei aus dem
+        # Modulpfad.
+        if pDatei==None:
+            tDatei = os.path.join(os.path.dirname(__file__),"AudioSignal.mp3")
+            pDatei = Datei(tDatei)
+        
+        self.__datei = pDatei
+        
+    def signalisiere(self):
+        """Auftrag. Übermittelt das Signal an den Benutzer.
+        
+        Parameter 
+            --- keine ---
+        """
+        self.__audioPlayer.wiedergeben()
+        
+    # Attribute (verdeckte Getter und Setter)
+    datei = property(nenneDatei, setzeDatei, doc="Die Audiodatei, die für das "\
+        "Signal verwendet werden soll.")

source/iOS/signale/Signal.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+class Signal(object):
+    """Die Klasse Signal dient der Übermittlung von Signalen an den Benutzer."""
+
+    def __init__(self):
+        """Konstruktor. Initialisiert das Signal.
+        
+        Parameter:
+            --- keine ---
+        """
+        pass
+
+    def signalisiere(self):
+        """Auftrag. Übermittelt das Signal an den Benutzer.
+        
+        Parameter 
+            --- keine ---
+        """
+        pass
+

source/iOS/signale/TextSignal.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+from velamentum.signale.Signal import Signal
+import dialogs
+
+class TextSignal(Signal):
+    """Die Klasse TextSignal dient der Übermittlung von Textsignalen 
+    an den Benutzer.
+    
+    Attribute:
+        text (Zeichenkette): Text des Signals.
+    """
+
+    def __init__(self, pText="TextSignal"):
+        """Konstruktor. Initialisiert das Signal.
+        
+        Parameter:
+            [optional] pText (Zeichenkette): Text des Signals.
+        """
+        Signal.__init__(self)
+        self.text = pText
+
+    def nenneText(self):
+        """Anfrage. Gibt den Text des Signals zurück.
+        
+        Parameter:
+            --- keine ---
+            
+        Rückgabe (Zeichenkette): Text des Signals.
+        """
+        return self.text
+        
+    def setzeText(self, pText):
+        """Auftrag. Ändert den Text des Signals.
+        
+        Parameter:
+            pText (Zeichenkette): Text des Signals.        
+        """
+        self.text = pText
+        
+    def signalisiere(self):
+        """Auftrag. Übermittelt das Signal an den Benutzer.
+        
+        Parameter 
+            --- keine ---
+        """
+        dialogs.hud_alert(self.text)

source/iOS/signale/VibrationsSignal.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+from velamentum.signale.Signal import Signal
+import dialogs
+
+class VibrationsSignal(Signal):
+    """Die Klasse Signal dient der Übermittlung von Vibrationssignalen
+    an den Benutzer.
+    
+    Attribute
+        dauer (Zahl): Dauer der Vibration in Millisekunden."""
+
+    def __init__(self, pDauer=300):
+        """Konstruktor. Initialisiert das Vibrationssignal.
+        
+        Parameter:
+            [optional] pDauer (Zahl): Dauer der Vibration in Millisekunden.
+                [Standardwert: 300]
+        """
+        Signal.__init__(self)
+        self.dauer = pDauer
+
+    def nenneDauer(self):
+        """Anfrage. Gibt die Dauer der Vibration zurück.
+        
+        Parameter:
+            --- keine ---
+        
+        Rückgabe (Zahl): Dauer der Vibration in Millisekunden.
+        """
+        return self.dauer
+        
+    def setzeDauer(self, pDauer):
+        """Auftrag. Ändert die Dauer der Vibration.
+        
+        Parameter:
+            pDauer: Dauer der Vibration in Millisekunden.
+        """
+        self.dauer = pDauer
+        
+    def signalisiere(self):
+        """Auftrag. Übermittelt das Signal an den Benutzer.
+        
+        Parameter:
+            --- keine ---
+        """
+        dialogs.alert('Fehler', 'Für iOS nicht implementiert.')

source/iOS/sprache/Sprachausgabe.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+import speech
+
+class Sprachausgabe(object):
+    """Die Klasse Sprachausgabe ermöglicht die Umwandlung von Text in Sprache.
+    Dieser wird dann als gesprochene Sprache über die Lautsprecher ausgegeben.
+    
+    Attribute:
+        text (Zeichenkette): Der umzuwandelnde Text."""
+
+    def __init__(self, pText="Text"):
+        """Auftrag. Initialisiert die Sprachausgabe.
+        
+        Parameter:
+            [optional] pText (Zeichenkette): Der umzuwandelnde Text.
+        """
+        self.text = pText
+
+    def setzeText(self, pText):
+        """Auftrag. Ändert den umzuwandelnden Text.
+        
+        Parameter:
+            pText (Zeichenkette):
+        """
+        self.text = pText
+
+    def nenneText(self):
+        """Anfrage. Gibt den umzuwandelnden Text zurück.
+        
+        Parameter:
+            --- keine ---
+        
+        Rückgabe (Zeichenkette): Der umzuwandelnde Text.
+        """
+        return self.text
+
+    def sprichtNoch(self):
+        """Anfrage. Überprüft, ob noch eine Sprachausgabe läuft.
+        
+        Parameter:
+            --- keine ---
+        
+        Rückgabe (Wahrheitswert): Liefert True, wenn die Sprachausgabe noch
+            läuft, sonst False.
+        """
+        return speech.is_speaking()
+
+    def sprechen(self):
+        """Auftrag. Wandelt den Text in Sprache um und gibt ihn über die
+        Lautsprecher aus.
+        
+        Parameter:
+            --- keine ---
+        """
+        speech.say(self.text)

source/iOS/sprache/Spracheingabe.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+
+class Spracheingabe(object):
+    """Die Klasse Spracheingabe ermöglicht die Umwandlung von Sprache in Text.
+    Gesprochener Text wird aufgenommen und mittels einer Spracherkennung in
+    Text umgewandelt.
+    
+    Attribute:
+        text (Zeichenkette): Der erkannte Text."""
+
+    def __init__(self):
+        """Konstruktor: Initialisiert die Spracheingabe.
+        
+        Parameter:
+            --- keine ---
+        """
+        self.text = ""
+
+    def nenneText(self):
+        """Anfrage. Gibt den erkannten Text zurück.
+        
+        Parameter:
+            --- keine ---
+        
+        Rückgabe (Zeichenkette): Der erkannte Text.
+        """
+        return self.text
+
+    def erkenneSprache(self):
+        """Auftrag. Der gesprochene Text wird erkannt und im Attribut 'text'
+        gespeichert.
+        
+        Parameter:
+            --- keine ---
+        """
+        self.text = "In iOS nicht verfügbar"
+

source/iOS/ui/dialoge/Dialog.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+import dialogs
+
+class Dialog(object):
+    """Die Klasse Dialog stellt einen einfachen Dialog zur Verfuegung, der eine
+    Nachricht anzeigen kann und nach Bestätigung durch den Benutzer wieder
+    verschwindet.
+    
+    Attribute:
+        titel (Zeichenkette): Der Titel des Dialogs.
+        nachricht (Zeichenkette): Die Nachricht des Dialogs.
+    """
+
+    def __init__(self, pTitel="Titel", pNachricht="Nachricht"):
+        """Auftrag. Initialisiert den Dialog.
+        
+        Parameter:
+            [optional] pTitel (Zeichenkette): Der Titel des Dialogs.
+            [optional] pNachricht (Zeichenkette): Die Nachricht des Dialogs.
+        """
+        self.titel = pTitel
+        self.nachricht = pNachricht
+
+    def setzeNachricht(self, pNachricht):
+        """Auftrag. Ändert die Nachricht des Dialogs.
+        
+        Parameter:
+            pNachricht (Zeichenkette): Die Nachricht des Dialogs.
+        """
+        self.nachricht = pNachricht
+
+    def setzeTitel(self, pTitel):
+        """Auftrag. Ändert den Titel des Dialogs.
+        
+        Parameter:
+            pTitel (Zeichenkette): Der Titel des Dialogs.
+        """
+        self.titel = pTitel
+
+    def nenneNachricht(self):
+        """Anfrage. Gibt die Nachricht des Dialogs zurück.
+        
+        Parameter:
+            --- keine ---
+            
+        Rückgabe (Zeichenkette): Die Nachricht des Dialogs.
+        """
+        return self.titel
+
+    def nenneTitel(self):
+        """Anfrage. Gibt den Titel des Dialogs zurück.
+        
+        Parameter:
+            --- keine ---
+            
+        Rückgabe (Zeichenkette): Der Titel des Dialogs.
+        """
+        return self.titel
+
+    def zeigeNachricht(self,pNachricht):
+        """Auftrag. Kurzform für das Anzeigen eines Dialogs. Setzt die neue
+        Nachricht und zeigt den Dialog sofort an.
+        
+        Parameter:
+            pNachricht (Zeichenkette): Die Nachricht des Dialogs.
+        """
+        self.nachricht = pNachricht
+        self.zeige()
+
+    def zeige(self):
+        """Auftrag. Zeigt den Dialog an.
+        
+        Parameter:
+            --- keine ---
+        """
+        dialogs.alert(self.titel, self.nachricht, 'Ok', '', '', True)

source/iOS/ui/dialoge/EingabeDialog.py

@@ -0,0 +1,98 @@
+# -*- coding: utf-8 -*-
+from velamentum.ui.dialoge.Dialog import Dialog
+import dialogs
+
+class EingabeDialog(Dialog):
+    """Die Klasse EingabeDialog (erbt Attribute und Methoden von der Klasse
+    Dialog) stellt einen einfachen Dialog zur Eingabe von Zeichenketten zur
+    Verfügung.
+    
+    Attribute:
+        titel (Zeichenkette): Der Titel des Dialogs.
+        nachricht (Zeichenkette): Die Nachricht des Dialogs.
+        ergebnis (Zeichenkette): Der eingegebene Text.
+        nurZahlen (Wahrheitswert): Nur Zahlen als Eingabe erlauben.
+        wertAnzeigen (Wahrheitswert): Den aktuellen Wert im Eingabefeld
+            anzeigen.
+    """
+
+    def __init__(self, pTitel="EingabeDialog", pNachricht="Nachricht", pNurZahlen=False, 
+        pWertAnzeigen=False):
+        """Konstruktor. Initialisiert den EingabeDialog.
+        
+        Parameter:
+            [optional] pTitel (Zeichenkette): Der Titel des Dialogs.
+            [optional] pNachricht (Zeichenkette): Die Nachricht des Dialogs.
+            [optional] pNurZahlen (Wahrheitswert): Nur Zahlen als Eingabe
+                erlauben (Standardwert: False).
+            [optional] pWertAnzeigen (Wahrheitswert): Den aktuellen Wert im
+                Eingabefeld anzeigen (Standardwert: False).
+        """
+        Dialog.__init__(self, pTitel, pNachricht)
+        self.__ergebnis = ''
+        self.nurZahlen = pNurZahlen
+        self.wertAnzeigen = pWertAnzeigen
+
+    def nenneErgebnis(self):
+        """Anfrage. Gibt die eingegebene Zeichenkette zurück.
+        
+        Parameter:
+            --- keine ---
+        
+        Rückgabe (Zeichenkette): Die eingegebene Zeichenkette.
+        """
+        if self.__ergebnis == '' and self.nurZahlen:
+            self.__ergebnis = 0
+        return int(self.__ergebnis) if self.nurZahlen else self.__ergebnis
+        
+    def nenneNurZahlen(self):
+        """Anfrage. Gibt zurück, ob nur Zahlen als Eingabe zugelassen sind.
+        
+        Parameter:
+            --- keine ---
+        
+        Rückgabe (Wahrheitswert): Sollen nur Zahlen als Eingabe zugelassen sein?
+        """
+        return self.nurZahlen
+    
+    def nenneWertAnzeigen(self):
+        """Anfrage. Gibt zurück, ob der aktuelle Wert im Eingabefeld angezeigt
+        werden soll.
+        
+        Parameter:
+            --- keine ---
+        
+        Rückgabe (Wahrheitswert): Soll der aktuelle Wert bei der Eingabe
+            angezeigt werden?
+        """
+        return self.wertAnzeigen
+        
+    def setzeNurZahlen(self, pNurZahlen):
+        """Auftrag. Legt fest, ob nur Zahlen als Eingabe zugelassen sind.
+        
+        Parameter:
+            pNurZahlen (Wahrheitswert): Sollen nur Zahlen als Eingabe zugelassen
+                sein?
+        """
+        self.nurZahlen = pNurZahlen
+        
+    def setzeWertAnzeigen(self, pWertAnzeigen):
+        """Auftrag. Legt fest, ob der aktuelle Wert bei der Eingabe angezeigt
+        werden soll.
+        
+        Parameter:
+            pWertAnzeigen (Wahrheitswert): Soll der aktuelle Wert bei der
+                Eingabe angezeigt werden?
+        """
+        self.nurZahlen = pWertAnzeigen
+
+    def zeige(self):
+        """Auftrag. Zeigt den EingabeDialog an und speichert die eingegebene
+        Zeichenkette im Attribut 'ergebnis'.
+        
+        Parameter:
+            --- keine ---
+        """
+        self.__ergebnis = dialogs.input_alert(self.titel, self.nachricht, self.__ergebnis if self.wertAnzeigen else '', 'Ok', True)
+         
+    ergebnis = property(nenneErgebnis, doc="Die Eingabe des Benutzers.")

source/iOS/ui/dialoge/EntscheidungsDialog.py

@@ -0,0 +1,131 @@
+# -*- coding: utf-8 -*-
+from velamentum.ui.dialoge.Dialog import Dialog
+import dialogs
+
+class EntscheidungsDialog(Dialog):
+    """Die Klasse Dialog stellt einen einfachen Dialog mit zwei oder drei 
+    Tasten als Antwortmöglichkeiten zur Verfuegung. Der Text der Tasten ist
+    frei wählbar.
+    
+    Attribute:
+        titel (Zeichenkette): Der Titel des Dialogs.
+        nachricht (Zeichenkette): Die Nachricht des Dialogs.
+        ergebnis (Zahl): Die Nummer der ausgewählten Taste (1-3), 0 bei Abbruch
+            oder Fehler.
+        text1 (Zeichenkette): Der Text der ersten Taste.
+        text2 (Zeichenkette): Der Text der zweiten Taste.
+        text3 (Zeichenkette): Der Text der dritten Taste.
+        dreiTasten (Wahrheitswert): Anzahl der anzuzeigenden Tasten. True für
+            drei Tasten, False für zwei Tasten.        
+    """
+
+    def __init__(self, pTitel="Titel", pNachricht="Nachricht"):
+        """Konstruktor. Initialisiert den EntscheidungsDialog.
+        
+        Parameter:
+            [optional] pTitel (Zeichenkette): Der Titel des Dialogs.
+            [optional] pNachricht (Zeichenkette): Die Nachricht des Dialogs.
+        """
+        Dialog.__init__(self, pTitel, pNachricht)
+        self.ergebnis = 0
+        self.text1 = "Ja"
+        self.text2 = "Nein"
+        self.text3 = "Vielleicht"
+        self.dreiTasten = False
+
+    def setzeText1(self, pText):
+        """Auftrag. Ändert den Text der ersten Taste.
+        
+        Parameter:
+            pText (Zeichenkette): Text der Taste.
+        """
+        self.text1 = pText
+
+    def setzeText2(self, pText):
+        """Auftrag. Ändert den Text der zweiten Taste.
+        
+        Parameter:
+            pText (Zeichenkette): Text der Taste.
+        """
+        self.text2 = pText
+
+    def setzeText3(self, pText):
+        """Auftrag. Ändert den Text der dritten Taste.
+        
+        Parameter:
+            pText (Zeichenkette): Text der Taste.
+        """
+        self.text3 = pText
+
+    def setzeDreiTasten(self, pDreiTasten):
+        """Auftrag. Legt fest, ob zwei oder drei Tasten angezeigt werden sollen.
+        
+        Parameter:
+            dreiTasten (Wahrheitswert): Anzahl der anzuzeigenden Tasten. 
+                True für drei Tasten, False für zwei Tasten. 
+        """
+        self.dreiTasten = pDreiTasten
+
+    def nenneErgebnis(self):
+        """Anfrage. Gibt die Nummer der gewählten Taste (1-3) oder 0 bei einem
+        Abbruch oder Fehler aus.
+        
+        Parameter:
+            --- keine ---
+            
+        Rückgabe (Zahl): Fehler oder Abbruch durch den Benutzer => 0,
+            Taste gedrückt => Nummer der Taste (1-3).
+        """
+        return self.ergebnis
+
+    def nenneText1(self):
+        """Anfrage. Gibt den Text der ersten Taste zurück.
+        
+        Parameter:
+            --- keine ---
+        
+        Rückgabe (Zeichenkette): Der Text der ersten Taste.
+        """
+        return self.text1
+
+    def nenneText2(self):
+        """Anfrage. Gibt den Text der zweiten Taste zurück.
+        
+        Parameter:
+            --- keine ---
+        
+        Rückgabe (Zeichenkette): Der Text der zweiten Taste.
+        """
+        return self.text2
+    
+    def nenneText3(self):
+        """Anfrage. Gibt den Text der dritten Taste zurück.
+        
+        Parameter:
+            --- keine ---
+        
+        Rückgabe (Zeichenkette): Der Text der dritten Taste.
+        """
+        return self.text3
+
+    def nenneDreiTasten(self):
+        """Anfrage. Gibt zurück ob zwei (False) oder drei (True) Tasten 
+        angezeigt werden sollen.
+        
+        Parameter:
+            --- keine ---
+            
+        Rückgabe (Wahrheitswert): True, falls drei Tasten angezeigt werden
+            sollen, False sonst.
+        """
+        return self.dreiTasten
+
+    def zeige(self):
+        """Auftrag. Zeigt den EntscheidungsDialog an und speichert die Auswahl
+        im Attribut 'ergebnis'.
+        
+        Parameter:
+            --- keine ---
+        """
+
+        self.ergebnis = dialogs.alert(self.titel, self.nachricht, self.text1, self.text2, self.text3 if self.dreiTasten else '',True)

source/iOS/ui/dialoge/PasswortDialog.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+from velamentum.ui.dialoge.EingabeDialog import EingabeDialog
+import dialogs
+
+class PasswortDialog(EingabeDialog):
+    """Die Klasse EingabeDialog (erbt Attribute und Methoden von der Klasse
+    EingabeDialog) stellt einen einfachen Dialog zur Eingabe von Passwörtern zur
+    Verfügung. Im Unterschied zum Eingabedialog wird die Zeichenkette während
+    der Eingabe nicht angezeigt.
+    
+    Attribute:
+        titel (Zeichenkette): Der Titel des Dialogs.
+        nachricht (Zeichenkette): Die Nachricht des Dialogs.
+        ergebnis (Zeichenkette): Der eingegebene Text.
+    """
+
+    def __init__(self, pTitel="Titel", pNachricht="Nachricht", pNurZahlen=False):
+        """Konstruktor. Initialisiert den PasswortDialog.
+        
+        Parameter:
+            [optional] pTitel (Zeichenkette): Der Titel des Dialogs.
+            [optional] pNachricht (Zeichenkette): Die Nachricht des Dialogs.
+            [optional] pNurZahlen (Wahrheitswert): Nur Zahlen als Eingabe
+                erlauben (Standardwert: False).
+        """
+        EingabeDialog.__init__(self, pTitel, pNachricht, pNurZahlen=False)
+
+    def zeige(self):
+        """Auftrag. Zeigt den PasswortDialog an und speichert die eingegebene
+        Zeichenkette im Attribut 'ergebnis'.
+        
+        Parameter:
+            --- keine ---
+        """
+        
+        self.ergebnis = dialogs.password_alert(self.titel, self.nachricht,'','Ok',True)

source/iOS/werkzeuge/System.py

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+import velamentum.dateien.Datei
+import console
+
+class System(object):
+    """Die Klasse System dient dem Zugriff auf bestimmte Funktionen des Systems.
+    
+    Attribute:
+        --- keine ---
+    """
+    @staticmethod
+    def oeffneDatei(pDatei):
+        console.open_in(pDatei.nennePfad())
+        

source/iOS/werkzeuge/Zufallsgenerator.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+
+import random
+import os
+
+class Zufallsgenerator(object):
+    """Die Klasse Zufallsgenerator bietet die Möglichkeit einfach Zuffallszahlen
+    zu generieren.
+    
+    Attribute:
+        min (Zahl): Untere Grenze für die generierten Zufallszahlen.
+        max (Zahl): Obere Grenze für die generierten Zufallszahlen.
+        ergebnis (Zahl): Die zuletzt generierte Zufallszahl.
+    """
+
+    def __init__(self, pMin=1, pMax=6):
+        """Konstruktor. Initialisiert den Zufallsgenerator, generiert eine erste
+        Zufallszahl und speichert sie im Attribut ergebnis.
+        
+        Parameter:
+            [optional] min (Zahl): Kleinste mögliche Zufallszahl.
+            [optional] max (Zahl): Größte mögliche Zufallszahl.
+        """
+        random.seed(os.urandom(8));
+        self.min = pMin
+        self.max = pMax
+        self.ergebnis = random.randrange(self.min, self.max+1)
+
+    def setzeMinimum(self, pMin):
+        """Auftrag. Ändert das Minimum (kleinste mögliche Zufallszahl).
+        
+        Parameter:
+            pMin (Zahl): Kleinste mögliche Zufallszahl.
+        """
+        self.min = pMin
+
+    def setzeMaximum(self, pMax):
+        """Auftrag. Ändert das Maximum (größte mögliche Zufallszahl).
+        
+        Parameter:
+            pMax (Zahl): Größte mögliche Zufallszahl.
+        """
+        self.max = pMax
+
+    def nenneErgebnis(self):
+        """Anfrage. Gibt die zuletzt generierte Zufallszahl zurück. 
+                
+        Parameter:
+            --- keine ---
+        
+        Rückgabe (Zahl): Die zuletzt generierte Zufallszahl.
+        """
+        return self.ergebnis
+
+    def nenneMinimum(self):
+        """Anfrage. Gibt das eingestellte Minimum (kleinste mögliche
+        Zufallszahl) zurück.
+        
+        Parameter:
+            --- keine ---
+            
+        Rückgabe (Zahl): Kleinste mögliche Zufallszahl.
+        """
+        return self.min
+
+    def nenneMaximum(self):
+        """Anfrage. Gibt das eingestellte Maximum (größte mögliche Zufallszahl) 
+        zurück.
+        
+        Parameter:
+            --- keine ---
+            
+        Rückgabe (Zahl): Größte mögliche Zufallszahl.
+        """
+        return self.max
+    
+    def generiere(self):
+        """Auftrag. Generiert eine neue Zufallszahl und speichert sie im
+        Attribut 'ergebnis'.
+        
+        Parameter:
+            --- keine ---
+        """
+        self.ergebnis = random.randrange(self.min, self.max+1)
+
+

source/iOS/werkzeuge/Zwischenablage.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+import clipboard
+
+class Zwischenablage(object):
+    """Die Klasse dient dem Zugriff auf die Zwischenablage des Systems.
+    
+    Attribute:
+        text (Zeichenkette): Der Text in der Zwischenablage des Systems.
+    """
+
+    def __init__(self):
+        """Konstruktor. Initialisiert die Zwischenablage.
+        
+        Parameter:
+            --- keine ---
+        """
+        pass
+
+    @staticmethod
+    def nenneText(self):
+        """Anfrage. Gibt den Text aus der Zwischenablage zurück.
+        
+        Parameter 
+            --- keine ---
+            
+        Rückgabe (Zeichenkette): Der Inhalt der Zwischenablage.
+        """
+        return clipboard.get()
+        
+    @staticmethod
+    def setzeText(self, pText):
+        """Auftrag. Schreibt den Text in die Zwischenablage.
+        
+        Parameter 
+            pText (Zeichenkette): Der Text, der in die Zwischenablage 
+                geschrieben werden soll.
+        """
+        clipboard.set(pText)
+        
+    # Attribute (verdeckte Getter und Setter)
+    text = property (nenneText, setzeText, doc="Der Text in der" \
+        "Zwischenablage des Systems.")
+