.gitignore

@@ -1,7 +1,6 @@
 # ---> Java
 # Compiled class file
 *.class
-src/java/velamentum
 
 # Log file
 *.log

README.md

@@ -1,20 +1,3 @@
 # velamentumRS
 
 Fork von velamentum mit dem Ziel sowohl python am Desktop als auch eine Java Unterstützung herzustellen.
-
-## Java
-
-**Unterstützte Bibliotheken:**
- - velamentum.ui.dialoge.Dialog
- - velamentum.ui.dialoge.EingabeDialog
- - velamentum.ui.dialoge.EingabeDialog_alt
- - velamentum.ui.dialoge.EntscheidungsDialog
- - velamentum.ui.dialoge.PasswortDialog
-
-### Buildprozess
-Im Verzeichnis `src/java` befindet sich ein Makefile.
-
-`make` erstellt aus den Quellen alle benötigten Klassen-Dateien in das Verzeichnis
-`src/java/velamentum`. Diese sollten dann im Java-Classpath mit `javac -cp pfad/zu/java/velamentum`
-oder in der Umgebungsvariable `export CLASSPATH=$CLASSPATH:pfad/zu/java/velamentum` angegeben
-werden.

SchereSteinPapier.java

@@ -0,0 +1,64 @@
+import velamentum.Dialog;
+import velamentum.EntscheidungsDialog;
+import velamentum.werkzeuge.Zufallsgenerator;
+
+public class SchereSteinPapier {
+
+	public static void main(String[] args) {
+		
+		Dialog dialog = new Dialog("Schere, Stein, Papier", "Willkommen zum Spiel!");
+		dialog.zeige();
+		
+		EntscheidungsDialog eDialog = new EntscheidungsDialog("Schere, Stein, Papier", "Bitte wählen Sie ihren Gegenstand");
+		eDialog.setzeText1("Schere");
+		eDialog.setzeText2("Stein");
+		eDialog.setzeText3("Papier");
+		eDialog.setzeDreiTasten(true);
+		
+		eDialog.zeige();
+		System.out.println(eDialog.nenneErgebnis());
+		
+		Zufallsgenerator zufall = new Zufallsgenerator(1, 3);
+		System.out.println(zufall.nenneErgebnis());
+		
+		if(zufall.nenneErgebnis() == 1) {
+			dialog.zeigeNachricht("Ich habe Schere gewählt.");
+			if(eDialog.nenneErgebnis() == 1) {
+				dialog.zeigeNachricht("Unentschieden!");
+			}
+			else if(eDialog.nenneErgebnis() == 2) {
+				dialog.zeigeNachricht("Du hast gewonnen!");
+			}
+			else {
+				dialog.zeigeNachricht("Ich habe gewonnen!");
+			}
+		}
+		else if(zufall.nenneErgebnis() == 2) {
+			dialog.zeigeNachricht("Ich habe Stein gewählt.");
+			if(eDialog.nenneErgebnis() == 2) {
+				dialog.zeigeNachricht("Unentschieden!");
+			}
+			else if(eDialog.nenneErgebnis() == 1) {
+				dialog.zeigeNachricht("Ich habe gewonnen!");
+			}
+			else {
+				dialog.zeigeNachricht("Du hast gewonnen!");
+			}
+		}
+		else{
+			dialog.zeigeNachricht("Ich habe Papier gewählt.");
+			if(eDialog.nenneErgebnis() == 3) {
+				dialog.zeigeNachricht("Unentschieden!");
+			}
+			else if(eDialog.nenneErgebnis() == 2) {
+				dialog.zeigeNachricht("Ich habe gewonnen!");
+			}
+			else {
+				dialog.zeigeNachricht("Du hast gewonnen!");
+			}
+		}
+		
+
+	}
+
+}

src/Android/alle.py

@@ -1,22 +0,0 @@
-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

src/Android/android.py

@@ -1,2 +0,0 @@
-import androidhelper
-androide = androidhelper.Android()

src/Android/dateien/Datei.py

@@ -1,71 +0,0 @@
-# -*- 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.")

src/Android/dateien/DateiSystemElement.py

@@ -1,104 +0,0 @@
-# -*- 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.")
-    
-    

src/Android/dateien/Verzeichnis.py

@@ -1,29 +0,0 @@
-# -*- 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

src/Android/multimedia/AudioPlayer.py

@@ -1,178 +0,0 @@
-# -*- coding: utf-8 -*-
-import time
-import random
-import velamentum.dateien.Datei
-from velamentum.multimedia.Player import Player
-from velamentum.android import *
-
-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():
-            androide.mediaPlay(self.datei.nennePfad(), self._id, 
-                pSofortWiedergeben)
-            self.dauer = int(androide.mediaPlayInfo(self._id)[1]["duration"])
-        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 ---
-        """
-        androide.mediaPlayClose(self._id)
-
-    def nenneDauer(self):
-        """Anfrage. Gibt die Gesamtdauer der Datei zurück.
-        
-        Parameter:
-            --- keine ---
-            
-        Rückgabe (Zahl): Gesamtdauer der Datei in Millisekunden.
-        """
-        return self.dauer
-    
-    def nennePosition(self):
-        """Anfrage. Gibt die aktuelle Position der Wiedergabe zurück.
-        
-        Parameter:
-            --- keine ---
-            
-        Rückgabe (Zahl): Aktuelle Position der Wiedergabe in Millisekunden.
-        """
-        return int(androide.mediaPlayInfo(self._id)[1]["position"])
-    
-    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
-        
-        androide.mediaPlaySeek(pPosition, self._id)
-
-    
-    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.
-        """
-        Player.setzeDatei(self, pDatei)
-
-        if pDatei.istVorhanden():
-            androide.mediaPlay(self.datei.nennePfad(), self._id, False)
-            self.dauer = int(androide.mediaPlayInfo(self._id)[1]["duration"])
-        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 androide.mediaPlayInfo(self._id)[1]["looping"]
-        
-    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? 
-        """
-        return androide.mediaPlaySetLooping(self._id, pWiederholen)
-
-    def gibtWieder(self):
-        """Anfrage. Gibt an, ob die Datei gerade wiedergegeben wird.
-        
-        Parameter:
-            --- keine ---
-            
-        Rückgabe (Wahrheitswert): True falls gerade eine Wiedergabe läuft,
-            False sonst.
-        """
-        return androide.mediaIsPlaying(self._id)["result"]
-    
-    def wiedergeben(self):
-        """Auftrag. Startet die Wiedergabe der Multimediadaten. 
-        
-        Parameter 
-            --- keine ---
-        """
-        androide.mediaPlayStart(self._id)
-        
-    def pausieren(self):
-        """Auftrag. Pausiert die Wiedergabe der Multimediadaten. Die Wiedergabe
-        kann mit 'wiedergeben' fortgesetzt werden.
-        
-        Parameter 
-            --- keine ---
-        """
-        androide.mediaPlayPause(self._id)
-    
-    def stoppen(self):
-        """Auftrag. Stoppt die Wiedergabe der Multimediadaten. (Wie 'pausieren',
-        Wiedergabe kann jedoch nicht fortgesetzt werden, sondern beginnt dann
-        von vorne.
-        
-        Parameter 
-            --- keine ---
-        """
-        androide.mediaPlayPause(self._id)
-        self.setzePosition(0)
-    
-    # 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.")
-

src/Android/multimedia/AudioRecorder.py

@@ -1,58 +0,0 @@
-# -*- coding: utf-8 -*-
-import velamentum.dateien.Datei
-from velamentum.multimedia.Recorder import Recorder
-from velamentum.ui.dialoge.Dialog import Dialog
-from velamentum.android import *
-
-class AudioRecorder(Recorder):
-    """Die Klasse AudioRecorder dient der Aufnahme von Tondaten in eine Datei.
-    
-    Attribute:
-        --- von 'Recorder' geerbte ---
-    """
-
-    def __init__(self, pDatei=velamentum.dateien.Datei.Datei("/sdcard/aufnahme.m4a")):
-        """Konstruktor. Initialisiert den AudioRecorder.
-        
-        Parameter:
-            [optional] datei (Datei): Datei, in der die Aufnahme gespeichert
-                werden soll [Standardwert: Datei mit Pfad '/scard/aufnahme.m4a'].
-        """
-        Recorder.__init__(self, pDatei)
-        
-    def aufnehmen(self):
-        """Auftrag. Startet die Aufnahme der Multimediadaten. 
-        
-        HINWEIS: Die angegebene Datei wird überschrieben.
-        
-        Parameter 
-            --- keine ---
-        """
-        Recorder.aufnehmen(self)
-        androide.recorderStartMicrophone(self.datei.nennePfad())
-    
-    def stoppen(self):
-        """Auftrag. Stoppt die Aufnahme der Multimediadaten.
-        
-        Parameter 
-            --- keine ---
-        """
-        Recorder.stoppen(self)
-        androide.recorderStop()
-        
-    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 ---
-        """
-        self.aufnehmen()
-        dialog = Dialog("Audioaufnahme", "Aufnahme gestartet. Zum Beenden" \
-            "'Ok' drücken.")
-        dialog.zeige()
-        self.stoppen()
-

src/Android/multimedia/BildRecorder.py

@@ -1,51 +0,0 @@
-# -*- coding: utf-8 -*-
-import velamentum.dateien.Datei
-from velamentum.multimedia.Recorder import Recorder
-from velamentum.android import *
-
-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 ---
-        """
-        androide.cameraCapturePicture(self.datei.nennePfad())
-    
-    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 ---
-        """
-        androide.cameraInteractiveCapturePicture(self.datei.nennePfad())
-

src/Android/multimedia/JNIAudioRecorder.py

@@ -1,91 +0,0 @@
-# -*- coding: utf-8 -*-
-import velamentum.dateien.Datei
-from velamentum.multimedia.Recorder import Recorder
-from velamentum.ui.dialoge.Dialog import Dialog
-
-from jnius import autoclass
-
-from velamentum.android import *
-
-class JNIAudioRecorder(Recorder):
-    """Die Klasse AudioRecorder dient der Aufnahme von Tondaten in eine Datei.
-    
-    BUG: Die Nutzung aus der QPython-Konsole funktioniert derzeit nicht.
-    Der Aufruf aus einer Skriptdatei funktioniert hingegen problemlos.
-    
-    Attribute:
-        --- von 'Recorder' geerbte ---
-    """
-
-    def __init__(self, pDatei=velamentum.dateien.Datei.Datei("/sdcard/aufnahme.m4a")):
-        """Konstruktor. Initialisiert den JNIAudioRecorder.
-        
-        Parameter:
-            [optional] pDatei (Datei): Datei, in der die Aufnahme gespeichert
-                werden soll [Standardwert: Datei mit Pfad 
-                '/sdcard/aufnahme.m4a'].
-        """
-        Recorder.__init__(self, pDatei)
-        
-        # Recorder initialisieren
-        MediaRecorder = autoclass('android.media.MediaRecorder')
-        AudioSource = autoclass('android.media.MediaRecorder$AudioSource')
-        OutputFormat = autoclass('android.media.MediaRecorder$OutputFormat')
-        AudioEncoder = autoclass('android.media.MediaRecorder$AudioEncoder')
-        self.__mRecorder = MediaRecorder()
-        self.__mRecorder.setOutputFile(pDatei.nennePfad()) # Pfad der Datei
-        self.__mRecorder.setAudioSource(AudioSource.MIC) # Aufnahme vom Mikrofon
-        self.__mRecorder.setAudioChannels(1) # Mono
-        self.__mRecorder.setAudioEncodingBitRate(131072) # 128 kbps
-        self.__mRecorder.setAudioSamplingRate(48000) # 48 kHz
-        # ACHTUNG: Reihenfolge ist relevant! Erst Format, dann Encoder!
-        self.__mRecorder.setOutputFormat(OutputFormat.MPEG_4) # MP4-Container
-        self.__mRecorder.setAudioEncoder(AudioEncoder.AAC) # AAC-Format
-        
-    def __del__(self):
-        """Destruktor. Notwendig zur Freigabe des MediaRecorders beim Löschen
-        des Python-Objekts.
-        
-        Parameter:
-            --- keine ---
-        """
-        self.__mRecorder.release()
-
-    def aufnehmen(self):
-        """Auftrag. Startet die Aufnahme der Multimediadaten. 
-        
-        HINWEIS: Die angegebene Datei wird überschrieben.
-        
-        Parameter 
-            --- keine ---
-        """
-        Recorder.aufnehmen(self)
-        self.__mRecorder.setOutputFile(self.datei.nennePfad())    
-        self.__mRecorder.prepare()
-        self.__mRecorder.start()
-    
-    def stoppen(self):
-        """Auftrag. Stoppt die Aufnahme der Multimediadaten.
-        
-        Parameter 
-            --- keine ---
-        """
-        Recorder.stoppen(self)
-        self.__mRecorder.stop()
-        
-    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 ---
-        """
-        self.aufnehmen()
-        dialog = Dialog("Audioaufnahme", "Aufnahme gestartet. Zum Beenden" \
-            "'Ok' drücken.")
-        dialog.zeige()
-        self.stoppen()
-

src/Android/multimedia/Player.py

@@ -1,144 +0,0 @@
-# -*- coding: utf-8 -*-
-import time
-import velamentum.dateien.Datei
-from velamentum.android import *
-
-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 gibtWieder(self):
-        """Anfrage. Gibt an, ob die Datei gerade wiedergegeben wird.
-        
-        Parameter:
-            --- keine ---
-            
-        Rückgabe (Wahrheitswert): True falls gerade eine Wiedergabe läuft,
-            False sonst.
-        """
-        return False
-
-    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.")
-
-

src/Android/multimedia/Recorder.py

@@ -1,96 +0,0 @@
-# -*- coding: utf-8 -*-
-import time
-import velamentum.dateien.Datei
-from velamentum.android import *
-
-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("/sdcard/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
-

src/Android/multimedia/VideoRecorder.py

@@ -1,53 +0,0 @@
-# -*- coding: utf-8 -*-
-import velamentum.dateien.Datei
-from velamentum.multimedia.Recorder import Recorder
-from velamentum.android import *
-
-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("/sdcard/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)
-
-    def aufnehmen(self):
-        """Auftrag. Startet die Aufnahme der Multimediadaten. 
-        
-        HINWEIS: Die angegebene Datei wird überschrieben.
-        
-        Parameter 
-            --- keine ---
-        """
-        Recorder.aufnehmen(self)
-        androide.recorderCaptureVideo(self.datei.nennePfad())
-    
-    def stoppen(self):
-        """Auftrag. Stoppt die Aufnahme der Multimediadaten.
-        
-        Parameter 
-            --- keine ---
-        """
-        Recorder.stoppen(self)
-        androide.recorderStop()
-        
-    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 ---
-        """
-        androide.startInteractiveVideoRecording(self.datei.nennePfad())
-

src/Android/signale/AudioSignal.py

@@ -1,60 +0,0 @@
-# -*- 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.")

src/Android/signale/Signal.py

@@ -1,22 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.android import *
-
-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
-

src/Android/signale/TextSignal.py

@@ -1,45 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.signale.Signal import Signal
-
-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 ---
-        """
-        androide.makeToast(self.text)

src/Android/signale/VibrationsSignal.py

@@ -1,45 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.signale.Signal import Signal
-
-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 ---
-        """
-        androide.vibrate(self.dauer)

src/Android/sprache/Sprachausgabe.py

@@ -1,55 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.android import *
-
-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 androide.ttsIsSpeaking().result
-
-    def sprechen(self):
-        """Auftrag. Wandelt den Text in Sprache um und gibt ihn über die
-        Lautsprecher aus.
-        
-        Parameter:
-            --- keine ---
-        """
-        androide.ttsSpeak(self.text)

src/Android/sprache/Spracheingabe.py

@@ -1,39 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.android import *
-
-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 = androide.recognizeSpeech("Bitte sprechen!","de-DE",
-            "free_form").result
-

src/Android/ui/dialoge/Dialog.py

@@ -1,79 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.android import *
-
-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 ---
-        """
-        androide.dialogCreateAlert(self.titel, self.nachricht)
-        androide.dialogSetPositiveButtonText('Ok')
-        androide.dialogShow()
-        androide.dialogGetResponse()

src/Android/ui/dialoge/EingabeDialog.py

@@ -1,103 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.ui.dialoge.Dialog import Dialog
-from velamentum.android import *
-
-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 ---
-        """
-        androide.dialogCreateInput(self.titel, self.nachricht,
-            self.__ergebnis if self.wertAnzeigen else '',
-            'number' if self.nurZahlen else 'text')
-        androide.dialogSetPositiveButtonText('Ok')
-        androide.dialogShow()
-        self.__ergebnis = androide.dialogGetResponse().result['value']
-        
-    ergebnis = property(nenneErgebnis, doc="Die Eingabe des Benutzers.")

src/Android/ui/dialoge/EntscheidungsDialog.py

@@ -1,152 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.ui.dialoge.Dialog import Dialog
-from velamentum.android import *
-
-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 ---
-        """
-
-        androide.dialogCreateAlert(self.titel, self.nachricht)
-        androide.dialogSetPositiveButtonText(self.text1)
-        if self.dreiTasten:
-            androide.dialogSetNegativeButtonText(self.text3)
-            androide.dialogSetNeutralButtonText(self.text2)
-        else:            
-            androide.dialogSetNegativeButtonText(self.text2)
-        androide.dialogShow()
-        tmpErg = androide.dialogGetResponse().result
-        if 'which' in tmpErg:
-            if tmpErg['which'] == 'positive':
-                self.ergebnis=1
-            elif tmpErg['which'] == 'negative':
-                if self.dreiTasten:
-                    self.ergebnis=3
-                else:
-                    self.ergebnis=2
-            elif tmpErg['which'] == 'neutral':
-                self.ergebnis=2
-        else:
-            self.ergebnis = 0
-

src/Android/ui/dialoge/PasswortDialog.py

@@ -1,39 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.ui.dialoge.EingabeDialog import EingabeDialog
-from velamentum.android import *
-
-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 ---
-        """
-        androide.dialogCreateInput(self.titel, self.nachricht, None,
-            'numberPassword' if self.nurZahlen else 'textPassword')
-        androide.dialogSetPositiveButtonText('Ok')
-        androide.dialogShow()
-        self.ergebnis = androide.dialogGetResponse().result['value']

src/Android/werkzeuge/System.py

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

src/Android/werkzeuge/Zufallsgenerator.py

@@ -1,86 +0,0 @@
-# -*- 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)
-
-

src/Android/werkzeuge/Zwischenablage.py

@@ -1,43 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.android import *
-
-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 androide.getClipboard()
-
-    @staticmethod
-    def setzeText(self, pText):
-        """Auftrag. Schreibt den Text in die Zwischenablage.
-        
-        Parameter 
-            pText (Zeichenkette): Der Text, der in die Zwischenablage 
-                geschrieben werden soll.
-        """
-        androide.setClipboard(pText)
-        
-    # Attribute (verdeckte Getter und Setter)
-    text = property (nenneText, setzeText, doc="Der Text in der" \
-        "Zwischenablage des Systems.")
-

src/Examples/Desktop/Quiz.py

@@ -1,18 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.alle import *
-
-# Dialog vorbereiten und Begrüßung anzeigen
-dialog = Dialog("Quiz", "Willkommen zum Quiz!")
-dialog.zeige()
-
-frage = EntscheidungsDialog("Frage 1", "Wie viel ist 5+3?")
-frage.setzeText1("7")
-frage.setzeText2("8")
-frage.zeige()
-
-feedback = Dialog("Feedback", "")
-
-if frage.nenneErgebnis() == 2:
-    feedback.zeigeNachricht("Richtig!")
-else:
-    feedback.zeigeNachricht("Falsch!")

src/Examples/Desktop/SteinScherePapier.py

@@ -1,50 +0,0 @@
-# -*- 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)
-
-eDialog.zeige()
-
-print(eDialog.nenneErgebnis())
-
-# 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!")

src/Examples/Desktop/Zahlenraten.py

@@ -1,40 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.alle import *
-#from velamentum.ui.dialoge.Dialog import *
-#from velamentum.ui.dialoge.EntscheidungsDialog import *
-#from velamentum.ui.dialoge.EingabeDialog import *
-#from velamentum.werkzeuge.Zufallsgenerator 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 = PasswortDialog("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))

src/Examples/Sprachtest/Sprachtest.py

@@ -1,18 +0,0 @@
-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()

src/Examples/SteinScherePapier/SchereSteinPapier.java

@@ -1,64 +0,0 @@
-import velamentum.ui.dialoge.Dialog;
-import velamentum.ui.dialoge.EntscheidungsDialog;
-import velamentum.werkzeuge.Zufallsgenerator;
-
-public class SchereSteinPapier {
-
- public static void main(String[] args) {
-  
-  Dialog dialog = new Dialog("Schere, Stein, Papier", "Willkommen zum Spiel!");
-  dialog.zeige();
-  
-  EntscheidungsDialog eDialog = new EntscheidungsDialog("Schere, Stein, Papier", "Bitte wählen Sie ihren Gegenstand");
-  eDialog.setzeText1("Schere");
-  eDialog.setzeText2("Stein");
-  eDialog.setzeText3("Papier");
-  eDialog.setzeDreiTasten(true);
-  
-  eDialog.zeige();
-  System.out.println(eDialog.nenneErgebnis());
-  
-  Zufallsgenerator zufall = new Zufallsgenerator(1, 3);
-  System.out.println(zufall.nenneErgebnis());
-  
-  if(zufall.nenneErgebnis() == 1) {
-   dialog.zeigeNachricht("Ich habe Schere gewählt.");
-   if(eDialog.nenneErgebnis() == 1) {
-    dialog.zeigeNachricht("Unentschieden!");
-   }
-   else if(eDialog.nenneErgebnis() == 2) {
-    dialog.zeigeNachricht("Du hast gewonnen!");
-   }
-   else {
-    dialog.zeigeNachricht("Ich habe gewonnen!");
-   }
-  }
-  else if(zufall.nenneErgebnis() == 2) {
-   dialog.zeigeNachricht("Ich habe Stein gewählt.");
-   if(eDialog.nenneErgebnis() == 2) {
-    dialog.zeigeNachricht("Unentschieden!");
-   }
-   else if(eDialog.nenneErgebnis() == 1) {
-    dialog.zeigeNachricht("Ich habe gewonnen!");
-   }
-   else {
-    dialog.zeigeNachricht("Du hast gewonnen!");
-   }
-  }
-  else{
-   dialog.zeigeNachricht("Ich habe Papier gewählt.");
-   if(eDialog.nenneErgebnis() == 3) {
-    dialog.zeigeNachricht("Unentschieden!");
-   }
-   else if(eDialog.nenneErgebnis() == 2) {
-    dialog.zeigeNachricht("Ich habe gewonnen!");
-   }
-   else {
-    dialog.zeigeNachricht("Du hast gewonnen!");
-   }
-  }
-  
-
- }
-
-}

src/Examples/SteinScherePapier/SteinScherePapier.py

@@ -1,49 +0,0 @@
-# -*- 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!")

src/Examples/SuS/Schlauheitstest/Schlauheitstest.py

@@ -1,80 +0,0 @@
-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()

src/Examples/Zahlenraten/Zahlenraten.py

@@ -1,36 +0,0 @@
-# -*- 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))

src/desktop/alle.py

@@ -1,22 +0,0 @@
-#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

src/desktop/dateien/Datei.py

@@ -1,71 +0,0 @@
-# -*- 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.")

src/desktop/dateien/DateiSystemElement.py

@@ -1,104 +0,0 @@
-# -*- 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.")
-    
-    

src/desktop/dateien/Verzeichnis.py

@@ -1,29 +0,0 @@
-# -*- 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

src/desktop/desktop.py

@@ -1 +0,0 @@
-from tkinter import *

src/desktop/multimedia/AudioPlayer.py

@@ -1,178 +0,0 @@
-# -*- coding: utf-8 -*-
-import time
-import random
-import velamentum.dateien.Datei
-from velamentum.multimedia.Player import Player
-from velamentum.android import *
-
-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():
-            androide.mediaPlay(self.datei.nennePfad(), self._id, 
-                pSofortWiedergeben)
-            self.dauer = int(androide.mediaPlayInfo(self._id)[1]["duration"])
-        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 ---
-        """
-        androide.mediaPlayClose(self._id)
-
-    def nenneDauer(self):
-        """Anfrage. Gibt die Gesamtdauer der Datei zurück.
-        
-        Parameter:
-            --- keine ---
-            
-        Rückgabe (Zahl): Gesamtdauer der Datei in Millisekunden.
-        """
-        return self.dauer
-    
-    def nennePosition(self):
-        """Anfrage. Gibt die aktuelle Position der Wiedergabe zurück.
-        
-        Parameter:
-            --- keine ---
-            
-        Rückgabe (Zahl): Aktuelle Position der Wiedergabe in Millisekunden.
-        """
-        return int(androide.mediaPlayInfo(self._id)[1]["position"])
-    
-    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
-        
-        androide.mediaPlaySeek(pPosition, self._id)
-
-    
-    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.
-        """
-        Player.setzeDatei(self, pDatei)
-
-        if pDatei.istVorhanden():
-            androide.mediaPlay(self.datei.nennePfad(), self._id, False)
-            self.dauer = int(androide.mediaPlayInfo(self._id)[1]["duration"])
-        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 androide.mediaPlayInfo(self._id)[1]["looping"]
-        
-    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? 
-        """
-        return androide.mediaPlaySetLooping(self._id, pWiederholen)
-
-    def gibtWieder(self):
-        """Anfrage. Gibt an, ob die Datei gerade wiedergegeben wird.
-        
-        Parameter:
-            --- keine ---
-            
-        Rückgabe (Wahrheitswert): True falls gerade eine Wiedergabe läuft,
-            False sonst.
-        """
-        return androide.mediaIsPlaying(self._id)["result"]
-    
-    def wiedergeben(self):
-        """Auftrag. Startet die Wiedergabe der Multimediadaten. 
-        
-        Parameter 
-            --- keine ---
-        """
-        androide.mediaPlayStart(self._id)
-        
-    def pausieren(self):
-        """Auftrag. Pausiert die Wiedergabe der Multimediadaten. Die Wiedergabe
-        kann mit 'wiedergeben' fortgesetzt werden.
-        
-        Parameter 
-            --- keine ---
-        """
-        androide.mediaPlayPause(self._id)
-    
-    def stoppen(self):
-        """Auftrag. Stoppt die Wiedergabe der Multimediadaten. (Wie 'pausieren',
-        Wiedergabe kann jedoch nicht fortgesetzt werden, sondern beginnt dann
-        von vorne.
-        
-        Parameter 
-            --- keine ---
-        """
-        androide.mediaPlayPause(self._id)
-        self.setzePosition(0)
-    
-    # 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.")
-

src/desktop/multimedia/AudioRecorder.py

@@ -1,58 +0,0 @@
-# -*- coding: utf-8 -*-
-import velamentum.dateien.Datei
-from velamentum.multimedia.Recorder import Recorder
-from velamentum.ui.dialoge.Dialog import Dialog
-from velamentum.android import *
-
-class AudioRecorder(Recorder):
-    """Die Klasse AudioRecorder dient der Aufnahme von Tondaten in eine Datei.
-    
-    Attribute:
-        --- von 'Recorder' geerbte ---
-    """
-
-    def __init__(self, pDatei=velamentum.dateien.Datei.Datei("/sdcard/aufnahme.m4a")):
-        """Konstruktor. Initialisiert den AudioRecorder.
-        
-        Parameter:
-            [optional] datei (Datei): Datei, in der die Aufnahme gespeichert
-                werden soll [Standardwert: Datei mit Pfad '/scard/aufnahme.m4a'].
-        """
-        Recorder.__init__(self, pDatei)
-        
-    def aufnehmen(self):
-        """Auftrag. Startet die Aufnahme der Multimediadaten. 
-        
-        HINWEIS: Die angegebene Datei wird überschrieben.
-        
-        Parameter 
-            --- keine ---
-        """
-        Recorder.aufnehmen(self)
-        androide.recorderStartMicrophone(self.datei.nennePfad())
-    
-    def stoppen(self):
-        """Auftrag. Stoppt die Aufnahme der Multimediadaten.
-        
-        Parameter 
-            --- keine ---
-        """
-        Recorder.stoppen(self)
-        androide.recorderStop()
-        
-    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 ---
-        """
-        self.aufnehmen()
-        dialog = Dialog("Audioaufnahme", "Aufnahme gestartet. Zum Beenden" \
-            "'Ok' drücken.")
-        dialog.zeige()
-        self.stoppen()
-

src/desktop/multimedia/BildRecorder.py

@@ -1,51 +0,0 @@
-# -*- coding: utf-8 -*-
-import velamentum.dateien.Datei
-from velamentum.multimedia.Recorder import Recorder
-from velamentum.android import *
-
-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 ---
-        """
-        androide.cameraCapturePicture(self.datei.nennePfad())
-    
-    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 ---
-        """
-        androide.cameraInteractiveCapturePicture(self.datei.nennePfad())
-

src/desktop/multimedia/JNIAudioRecorder.py

@@ -1,91 +0,0 @@
-# -*- coding: utf-8 -*-
-import velamentum.dateien.Datei
-from velamentum.multimedia.Recorder import Recorder
-from velamentum.ui.dialoge.Dialog import Dialog
-
-from jnius import autoclass
-
-from velamentum.android import *
-
-class JNIAudioRecorder(Recorder):
-    """Die Klasse AudioRecorder dient der Aufnahme von Tondaten in eine Datei.
-    
-    BUG: Die Nutzung aus der QPython-Konsole funktioniert derzeit nicht.
-    Der Aufruf aus einer Skriptdatei funktioniert hingegen problemlos.
-    
-    Attribute:
-        --- von 'Recorder' geerbte ---
-    """
-
-    def __init__(self, pDatei=velamentum.dateien.Datei.Datei("/sdcard/aufnahme.m4a")):
-        """Konstruktor. Initialisiert den JNIAudioRecorder.
-        
-        Parameter:
-            [optional] pDatei (Datei): Datei, in der die Aufnahme gespeichert
-                werden soll [Standardwert: Datei mit Pfad 
-                '/sdcard/aufnahme.m4a'].
-        """
-        Recorder.__init__(self, pDatei)
-        
-        # Recorder initialisieren
-        MediaRecorder = autoclass('android.media.MediaRecorder')
-        AudioSource = autoclass('android.media.MediaRecorder$AudioSource')
-        OutputFormat = autoclass('android.media.MediaRecorder$OutputFormat')
-        AudioEncoder = autoclass('android.media.MediaRecorder$AudioEncoder')
-        self.__mRecorder = MediaRecorder()
-        self.__mRecorder.setOutputFile(pDatei.nennePfad()) # Pfad der Datei
-        self.__mRecorder.setAudioSource(AudioSource.MIC) # Aufnahme vom Mikrofon
-        self.__mRecorder.setAudioChannels(1) # Mono
-        self.__mRecorder.setAudioEncodingBitRate(131072) # 128 kbps
-        self.__mRecorder.setAudioSamplingRate(48000) # 48 kHz
-        # ACHTUNG: Reihenfolge ist relevant! Erst Format, dann Encoder!
-        self.__mRecorder.setOutputFormat(OutputFormat.MPEG_4) # MP4-Container
-        self.__mRecorder.setAudioEncoder(AudioEncoder.AAC) # AAC-Format
-        
-    def __del__(self):
-        """Destruktor. Notwendig zur Freigabe des MediaRecorders beim Löschen
-        des Python-Objekts.
-        
-        Parameter:
-            --- keine ---
-        """
-        self.__mRecorder.release()
-
-    def aufnehmen(self):
-        """Auftrag. Startet die Aufnahme der Multimediadaten. 
-        
-        HINWEIS: Die angegebene Datei wird überschrieben.
-        
-        Parameter 
-            --- keine ---
-        """
-        Recorder.aufnehmen(self)
-        self.__mRecorder.setOutputFile(self.datei.nennePfad())    
-        self.__mRecorder.prepare()
-        self.__mRecorder.start()
-    
-    def stoppen(self):
-        """Auftrag. Stoppt die Aufnahme der Multimediadaten.
-        
-        Parameter 
-            --- keine ---
-        """
-        Recorder.stoppen(self)
-        self.__mRecorder.stop()
-        
-    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 ---
-        """
-        self.aufnehmen()
-        dialog = Dialog("Audioaufnahme", "Aufnahme gestartet. Zum Beenden" \
-            "'Ok' drücken.")
-        dialog.zeige()
-        self.stoppen()
-

src/desktop/multimedia/Player.py

@@ -1,144 +0,0 @@
-# -*- coding: utf-8 -*-
-import time
-import velamentum.dateien.Datei
-from velamentum.android import *
-
-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 gibtWieder(self):
-        """Anfrage. Gibt an, ob die Datei gerade wiedergegeben wird.
-        
-        Parameter:
-            --- keine ---
-            
-        Rückgabe (Wahrheitswert): True falls gerade eine Wiedergabe läuft,
-            False sonst.
-        """
-        return False
-
-    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.")
-
-

src/desktop/multimedia/Recorder.py

@@ -1,96 +0,0 @@
-# -*- coding: utf-8 -*-
-import time
-import velamentum.dateien.Datei
-from velamentum.android import *
-
-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("/sdcard/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
-

src/desktop/multimedia/VideoRecorder.py

@@ -1,53 +0,0 @@
-# -*- coding: utf-8 -*-
-import velamentum.dateien.Datei
-from velamentum.multimedia.Recorder import Recorder
-from velamentum.android import *
-
-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("/sdcard/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)
-
-    def aufnehmen(self):
-        """Auftrag. Startet die Aufnahme der Multimediadaten. 
-        
-        HINWEIS: Die angegebene Datei wird überschrieben.
-        
-        Parameter 
-            --- keine ---
-        """
-        Recorder.aufnehmen(self)
-        androide.recorderCaptureVideo(self.datei.nennePfad())
-    
-    def stoppen(self):
-        """Auftrag. Stoppt die Aufnahme der Multimediadaten.
-        
-        Parameter 
-            --- keine ---
-        """
-        Recorder.stoppen(self)
-        androide.recorderStop()
-        
-    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 ---
-        """
-        androide.startInteractiveVideoRecording(self.datei.nennePfad())
-

src/desktop/signale/AudioSignal.py

@@ -1,60 +0,0 @@
-# -*- 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.")

src/desktop/signale/Signal.py

@@ -1,22 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.android import *
-
-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
-

src/desktop/signale/TextSignal.py

@@ -1,45 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.signale.Signal import Signal
-
-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 ---
-        """
-        androide.makeToast(self.text)

src/desktop/signale/VibrationsSignal.py

@@ -1,45 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.signale.Signal import Signal
-
-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 ---
-        """
-        androide.vibrate(self.dauer)

src/desktop/sprache/Sprachausgabe.py

@@ -1,55 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.android import *
-
-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 androide.ttsIsSpeaking().result
-
-    def sprechen(self):
-        """Auftrag. Wandelt den Text in Sprache um und gibt ihn über die
-        Lautsprecher aus.
-        
-        Parameter:
-            --- keine ---
-        """
-        androide.ttsSpeak(self.text)

src/desktop/sprache/Spracheingabe.py

@@ -1,39 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.android import *
-
-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 = androide.recognizeSpeech("Bitte sprechen!","de-DE",
-            "free_form").result
-

src/desktop/ui/dialoge/Dialog.py

@@ -1,90 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.desktop import *
-
-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 ---
-        """
-        desk = Tk()
-        #desk.geometry("400x200")
-        
-        desk.title(self.titel)
-        txtLable =  Label(desk, text=self.nachricht)
-        okBtn = Button(desk, text='Ok', command=desk.quit)
-
-        txtLable.pack()
-        okBtn.pack()
-        desk.mainloop()
-        desk.destroy()
-        #androide.dialogCreateAlert(self.titel, self.nachricht)
-        #androide.dialogSetPositiveButtonText('Ok')
-        #androide.dialogShow()
-        #androide.dialogGetResponse()

src/desktop/ui/dialoge/EingabeDialog.py

@@ -1,115 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.ui.dialoge.Dialog import Dialog
-from velamentum.desktop import *
-
-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 setzeErgebnis(self,feld):
-        self.__ergebnis = feld.get()
-
-    def zeige(self):
-        """Auftrag. Zeigt den EingabeDialog an und speichert die eingegebene
-        Zeichenkette im Attribut 'ergebnis'.
-        
-        Parameter:
-            --- keine ---
-        """
-        desk = Tk()
-        #desk.geometry("400x200")
-        
-
-        desk.title(self.titel)
-        txtLable =  Label(desk, text=self.nachricht)
-        eingabefeld = Entry(desk, bd=5, width=40)
-        okBtn = Button(desk, text='Ok', command=lambda:[self.setzeErgebnis(eingabefeld),desk.quit()])
-
-        txtLable.pack()
-        eingabefeld.pack()
-        okBtn.pack()
-
-        desk.mainloop()
-        desk.destroy()
-
-    ergebnis = property(nenneErgebnis, doc="Die Eingabe des Benutzers.")

src/desktop/ui/dialoge/EntscheidungsDialog.py

@@ -1,164 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.ui.dialoge.Dialog import Dialog
-from velamentum.desktop import *
-
-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 setzeErgebnisA(self):
-        """Auftrag. Ändert das Ergebnis für entsprechenden Button
-        """
-        self.ergebnis = 1
-
-    def setzeErgebnisB(self):
-        """Auftrag. Ändert das Ergebnis für entsprechenden Button
-        """
-        self.ergebnis = 2
-
-    def setzeErgebnisC(self):
-        """Auftrag. Ändert das Ergebnis für entsprechenden Button
-        """
-        self.ergebnis = 3
-
-    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 ---
-        """
-        
-        desk = Tk()
-        #desk.geometry("400x200")
-        
-
-        desk.title(self.titel)
-        txtLable =  Label(desk, text=self.nachricht)
-        btn1 = Button(desk, text=self.text1, command=lambda:[self.setzeErgebnisA(),desk.quit()])
-        btn2 = Button(desk, text=self.text2, command=lambda:[self.setzeErgebnisB(),desk.quit()])
-        
-        txtLable.grid(row=0,column=0,columnspan=3,pady=5)
-        btn1.grid(row=1,column=0,padx=4)
-        btn2.grid(row=1,column=1,padx=4)
-
-        if self.dreiTasten:
-            btn3 = Button(desk, text=self.text3, command=lambda:[self.setzeErgebnisC(),desk.quit()])
-            btn3.grid(row=1,column=2,padx=4)
-        
-        desk.mainloop()
-        desk.destroy()

src/desktop/ui/dialoge/PasswortDialog.py

@@ -1,52 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.ui.dialoge.EingabeDialog import EingabeDialog
-from velamentum.desktop import *
-
-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 setzeErgebnis(self,feld):
-        self.__ergebnis = feld.get()
-    
-    def zeige(self):
-        """Auftrag. Zeigt den PasswortDialog an und speichert die eingegebene
-        Zeichenkette im Attribut 'ergebnis'.
-        
-        Parameter:
-            --- keine ---
-        """
-        desk = Tk()
-        #desk.geometry("400x200")
-        
-
-        desk.title(self.titel)
-        txtLable =  Label(desk, text=self.nachricht)
-        eingabefeld = Entry(desk, bd=5, width=40, show='*')
-        okBtn = Button(desk, text='Ok', command=lambda:[self.setzeErgebnis(eingabefeld),desk.quit()])
-
-        txtLable.pack()
-        eingabefeld.pack()
-        okBtn.pack()
-
-        desk.mainloop()
-        desk.destroy()

src/desktop/werkzeuge/System.py

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

src/desktop/werkzeuge/Zufallsgenerator.py

@@ -1,86 +0,0 @@
-# -*- 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)
-
-

src/desktop/werkzeuge/Zwischenablage.py

@@ -1,43 +0,0 @@
-# -*- coding: utf-8 -*-
-from velamentum.android import *
-
-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 androide.getClipboard()
-
-    @staticmethod
-    def setzeText(self, pText):
-        """Auftrag. Schreibt den Text in die Zwischenablage.
-        
-        Parameter 
-            pText (Zeichenkette): Der Text, der in die Zwischenablage 
-                geschrieben werden soll.
-        """
-        androide.setClipboard(pText)
-        
-    # Attribute (verdeckte Getter und Setter)
-    text = property (nenneText, setzeText, doc="Der Text in der" \
-        "Zwischenablage des Systems.")
-

src/iOS/alle.py

@@ -1,22 +0,0 @@
-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

src/iOS/dateien/Datei.py

@@ -1,71 +0,0 @@
-# -*- 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.")

src/iOS/dateien/DateiSystemElement.py

@@ -1,104 +0,0 @@
-# -*- 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.")
-    
-    

src/iOS/dateien/Verzeichnis.py

@@ -1,29 +0,0 @@
-# -*- 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

src/iOS/multimedia/AudioPlayer.py

@@ -1,166 +0,0 @@
-# -*- 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.")
-

src/iOS/multimedia/AudioRecorder.py

@@ -1,21 +0,0 @@
-# -*- 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.')

src/iOS/multimedia/BildRecorder.py

@@ -1,52 +0,0 @@
-# -*- 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)
-

src/iOS/multimedia/Player.py

@@ -1,132 +0,0 @@
-# -*- 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.")
-
-

src/iOS/multimedia/Recorder.py

@@ -1,95 +0,0 @@
-# -*- 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
-

src/iOS/multimedia/VideoRecorder.py

@@ -1,21 +0,0 @@
-# -*- 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.')